(* Content-type: application/vnd.wolfram.mathematica *)

(*** Wolfram Notebook File ***)
(* http://www.wolfram.com/nb *)

(* CreatedBy='Mathematica 12.2' *)

(*CacheID: 234*)
(* Internal cache information:
NotebookFileLineBreakTest
NotebookFileLineBreakTest
NotebookDataPosition[       158,          7]
NotebookDataLength[    221222,       4820]
NotebookOptionsPosition[    210021,       4619]
NotebookOutlinePosition[    216652,       4771]
CellTagsIndexPosition[    216580,       4766]
WindowFrame->Normal*)

(* Beginning of Notebook Content *)
Notebook[{
Cell["Quiz 4", "ProblemTitle"],

Cell["Problem 1", "ProblemSectionNoFeedback",
 TaggingRules->{"QuestionNum" -> "1"}],

Cell[TextData[{
 "Which of these inputs will return an association, given this dataset as the \
value of ",
 StyleBox["data", "InlineFormula"],
 "?"
}], "ProblemCaption"],

Cell[CellGroupData[{

Cell[BoxData[
 RowBox[{"data", "=", 
  RowBox[{"Dataset", "[", 
   RowBox[{"<|", 
    RowBox[{
     RowBox[{"\"\<1st\>\"", "\[Rule]", "323"}], ",", 
     RowBox[{"\"\<2nd\>\"", "\[Rule]", "277"}], ",", 
     RowBox[{"\"\<3rd\>\"", "\[Rule]", "709"}]}], "|>"}], "]"}]}]], "Input",
 CellChangeTimes->{{3.7983799219505367`*^9, 3.7983799828497667`*^9}, {
  3.7983800703615427`*^9, 3.7983800727187557`*^9}},
 CellLabel->"In[55]:="],

Cell[BoxData[
 TemplateBox[{
   TagBox[
    DynamicModuleBox[{
     TypeSystem`NestedGrid`PackagePrivate`$state$$ = 
      Data`UnorderedAssociation[
       "DisplayedRowCount" -> 20, "RowCount" -> 3, "Length" -> 3, 
        "InitialType" -> TypeSystem`Assoc[
          TypeSystem`Atom[
           TypeSystem`Enumeration["1st", "2nd", "3rd"]], 
          TypeSystem`Atom[Integer], 3], "DisplayedColumnCount" -> 20, 
        "DataRowCount" -> 0, "Shape" -> TypeSystem`PackageScope`Limited[
          TypeSystem`PackageScope`ColumnShape[
           TypeSystem`PackageScope`KeyValueShape[
            TypeSystem`PackageScope`AtomShape[27.], 
            TypeSystem`PackageScope`AtomShape[34]]], 3, {}], 
        "DataColumnCount" -> 0, "InitialData" -> 
        TypeSystem`PackageScope`CacheHandle[19647521], "Type" -> 
        TypeSystem`Assoc[
          TypeSystem`Atom[
           TypeSystem`Enumeration["1st", "2nd", "3rd"]], 
          TypeSystem`Atom[Integer], 3], "HandleQ" -> True, "Meta" -> {}, 
        "RowTarget" -> 20, "Data" -> 
        TypeSystem`PackageScope`CacheHandle[19647521]], 
      TypeSystem`NestedGrid`PackagePrivate`$path$$ = {}, 
      TypeSystem`NestedGrid`PackagePrivate`$pos$$ = 1, 
      TypeSystem`NestedGrid`PackagePrivate`$grid$$ = 
      DynamicModule[{
        TypeSystem`NestedGrid`PackagePrivate`renderedGrid = Deploy[
           Style[
            Grid[{{
               Item[
                Pane[
                 Annotation[
                  EventHandler[
                   MouseAppearance[
                    Mouseover["1st", 
                    Style[
                    "1st", FontColor -> 
                    RGBColor[
                    0.27450980392156865`, 0.5372549019607843, 
                    0.792156862745098]]], "LinkHand"], {"MouseClicked", 1} :> 
                   TypeSystem`NestedGrid`PackagePrivate`updateState[
                    TypeSystem`NestedGrid`PackagePrivate`$state$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$path$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$pos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$grid$$, 278042890][{
                    
                    Key["1st"]}]], 
                  TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[278042890][
                   GeneralUtilities`Slice[
                    Key["1st"]]], "Mouse"], 
                 ImageSize -> {{27., Full}, Automatic}], Background -> 
                GrayLevel[0.95], Alignment -> {Left, Baseline}], 
               Pane[
                Annotation[
                 RawBoxes["323"], 
                 TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[278042890][
                 
                  GeneralUtilities`Slice[
                   Key["1st"]]], "Mouse"], 
                ImageSize -> {{34, Full}, Automatic}, 
                Alignment -> {Left, Baseline}]}, {
               Item[
                Pane[
                 Annotation[
                  EventHandler[
                   MouseAppearance[
                    Mouseover["2nd", 
                    Style[
                    "2nd", FontColor -> 
                    RGBColor[
                    0.27450980392156865`, 0.5372549019607843, 
                    0.792156862745098]]], "LinkHand"], {"MouseClicked", 1} :> 
                   TypeSystem`NestedGrid`PackagePrivate`updateState[
                    TypeSystem`NestedGrid`PackagePrivate`$state$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$path$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$pos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$grid$$, 278042890][{
                    
                    Key["2nd"]}]], 
                  TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[278042890][
                   GeneralUtilities`Slice[
                    Key["2nd"]]], "Mouse"], 
                 ImageSize -> {{27., Full}, Automatic}], Background -> 
                GrayLevel[0.95], Alignment -> {Left, Baseline}], 
               Pane[
                Annotation[
                 RawBoxes["277"], 
                 TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[278042890][
                 
                  GeneralUtilities`Slice[
                   Key["2nd"]]], "Mouse"], 
                ImageSize -> {{34, Full}, Automatic}, 
                Alignment -> {Left, Baseline}]}, {
               Item[
                Pane[
                 Annotation[
                  EventHandler[
                   MouseAppearance[
                    Mouseover["3rd", 
                    Style[
                    "3rd", FontColor -> 
                    RGBColor[
                    0.27450980392156865`, 0.5372549019607843, 
                    0.792156862745098]]], "LinkHand"], {"MouseClicked", 1} :> 
                   TypeSystem`NestedGrid`PackagePrivate`updateState[
                    TypeSystem`NestedGrid`PackagePrivate`$state$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$path$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$pos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$grid$$, 278042890][{
                    
                    Key["3rd"]}]], 
                  TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[278042890][
                   GeneralUtilities`Slice[
                    Key["3rd"]]], "Mouse"], 
                 ImageSize -> {{27., Full}, Automatic}], Background -> 
                GrayLevel[0.95], Alignment -> {Left, Baseline}], 
               Pane[
                Annotation[
                 RawBoxes["709"], 
                 TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[278042890][
                 
                  GeneralUtilities`Slice[
                   Key["3rd"]]], "Mouse"], 
                ImageSize -> {{34, Full}, Automatic}, 
                Alignment -> {Left, Baseline}]}}, BaseStyle -> {ContextMenu -> {
                 MenuItem["Copy position to clipboard", 
                  KernelExecute[
                   TypeSystem`NestedGrid`PackagePrivate`toCurrentPosition[
                   TypeSystem`NestedGrid`PackagePrivate`copyClip]], 
                  MenuEvaluator -> Automatic], 
                 MenuItem["Copy data to clipboard", 
                  KernelExecute[
                   TypeSystem`NestedGrid`PackagePrivate`toCurrentData[
                   TypeSystem`NestedGrid`PackagePrivate`$state$$, 
                    TypeSystem`NestedGrid`PackagePrivate`copyClip]], 
                  MenuEvaluator -> Automatic], Delimiter, 
                 MenuItem["Paste position in new cell", 
                  KernelExecute[
                   TypeSystem`NestedGrid`PackagePrivate`toCurrentPosition[
                   TypeSystem`NestedGrid`PackagePrivate`cellPaste]], 
                  MenuEvaluator -> Automatic], 
                 MenuItem["Paste data in new cell", 
                  KernelExecute[
                   TypeSystem`NestedGrid`PackagePrivate`toCurrentData[
                   TypeSystem`NestedGrid`PackagePrivate`$state$$, 
                    TypeSystem`NestedGrid`PackagePrivate`cellPaste]], 
                  MenuEvaluator -> Automatic]}, FontFamily -> "Verdana", 
               FontSize -> 12}, Alignment -> Left, RowMinHeight -> 1.5, 
             Dividers -> All, FrameStyle -> GrayLevel[0.85], 
             BaseStyle -> {FontFamily -> "Verdana", FontSize -> 12}], 
            LineBreakWithin -> False, ContextMenu -> {}, NumberMarks -> False,
             ShowAutoStyles -> False]], 
         TypeSystem`NestedGrid`PackagePrivate`initialQ = True, 
         TypeSystem`NestedGrid`PackagePrivate`self = $Failed}, 
        Dynamic[
         TypeSystem`NestedGrid`PackagePrivate`setupViewPath[
         TypeSystem`NestedGrid`PackagePrivate`$path$$, If[
            Not[TypeSystem`NestedGrid`PackagePrivate`initialQ], 
            
            Module[{TypeSystem`NestedGrid`PackagePrivate`tmpGrid$ = $Failed, 
              TypeSystem`NestedGrid`PackagePrivate`tmpData$ = 
              TypeSystem`NestedGrid`PackagePrivate`LookupCacheValue[
                TypeSystem`NestedGrid`PackagePrivate`$state$$["Data"]]}, 
             TypeSystem`NestedGrid`PackagePrivate`tmpGrid$ = 
              If[TypeSystem`NestedGrid`PackagePrivate`tmpData$ === 
                TypeSystem`NestedGrid`PackagePrivate`$NotCached, 
                TypeSystem`NestedGrid`PackagePrivate`renderedGrid, 
                TypeSystem`NestedGrid`PackagePrivate`renderGrid[
                TypeSystem`NestedGrid`PackagePrivate`$state$$, 
                 TypeSystem`NestedGrid`PackagePrivate`$path$$, 
                 TypeSystem`NestedGrid`PackagePrivate`$pos$$, 
                 TypeSystem`NestedGrid`PackagePrivate`$grid$$, 278042890][
                TypeSystem`NestedGrid`PackagePrivate`tmpData$]]; If[
               Not[
                FailureQ[TypeSystem`NestedGrid`PackagePrivate`tmpGrid$]], 
               TypeSystem`NestedGrid`PackagePrivate`renderedGrid = 
               TypeSystem`NestedGrid`PackagePrivate`tmpGrid$]; Null]]; 
          TypeSystem`NestedGrid`PackagePrivate`initialQ = False; 
          TypeSystem`NestedGrid`PackagePrivate`$pos$$; If[
            FailureQ[TypeSystem`NestedGrid`PackagePrivate`renderedGrid], 
            TypeSystem`SparseGrid[
             TypeSystem`H["(data no longer present)"]], 
            If[GeneralUtilities`$DebugMode, 
             Row[{TypeSystem`NestedGrid`PackagePrivate`renderedGrid, "  ", 
               TypeSystem`NestedGrid`PackagePrivate`formatState[
               TypeSystem`NestedGrid`PackagePrivate`$state$$, 
                TypeSystem`NestedGrid`PackagePrivate`$path$$, 
                TypeSystem`NestedGrid`PackagePrivate`$pos$$]}], 
             TypeSystem`NestedGrid`PackagePrivate`renderedGrid]]], 
         TrackedSymbols :> {TypeSystem`NestedGrid`PackagePrivate`$pos$$}], 
        DynamicModuleValues :> {}], 
      TypeSystem`NestedGrid`PackagePrivate`$posCell$$, 
      TypeSystem`NestedGrid`PackagePrivate`$topBar$$ = Dynamic[
        TypeSystem`NestedGrid`PackagePrivate`alignBar[
        TypeSystem`NestedGrid`PackagePrivate`$state$$][
         TypeSystem`NestedGrid`PackagePrivate`makeFramedBar[
          TypeSystem`PackageScope`Pathbar[
          TypeSystem`NestedGrid`PackagePrivate`$path$$, 
           TypeSystem`NestedGrid`PackagePrivate`updateState[
           TypeSystem`NestedGrid`PackagePrivate`$state$$, 
            TypeSystem`NestedGrid`PackagePrivate`$path$$, 
            TypeSystem`NestedGrid`PackagePrivate`$pos$$, 
            TypeSystem`NestedGrid`PackagePrivate`$grid$$, 278042890]]]], 
        TrackedSymbols :> {TypeSystem`NestedGrid`PackagePrivate`$path$$}], 
      TypeSystem`NestedGrid`PackagePrivate`$bottomBar$$ = Framed[
        Dynamic[
         Replace[
          MouseAnnotation[Null], {
          TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[278042890][Null] -> 
           "", TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[278042890][
             Pattern[TypeSystem`NestedGrid`PackagePrivate`path, 
              Blank[]]] :> (
            TypeSystem`NestedGrid`PackagePrivate`$lastPath = 
             TypeSystem`NestedGrid`PackagePrivate`path; 
            TypeSystem`NestedGrid`PackagePrivate`makePathTrail[
             TypeSystem`NestedGrid`PackagePrivate`path, 
              TypeSystem`NestedGrid`PackagePrivate`makePathElements]), Null :> 
           Spacer[10], Blank[] :> Spacer[10]}], TrackedSymbols :> {}], 
        FrameStyle -> None, ImageMargins -> 0, FrameMargins -> 0, Alignment -> 
        Top, ImageSize -> {Automatic, 14}]}, 
     DynamicBox[
      ToBoxes[
       Column[
        If[TypeSystem`NestedGrid`PackagePrivate`$path$$ == {}, {
          TypeSystem`NestedGrid`PackagePrivate`displayScrollBar[
          TypeSystem`NestedGrid`PackagePrivate`$grid$$, 
           TypeSystem`NestedGrid`PackagePrivate`$state$$, 
           TypeSystem`NestedGrid`PackagePrivate`$pos$$], 
          TypeSystem`NestedGrid`PackagePrivate`onDesktopShow[
           TypeSystem`NestedGrid`PackagePrivate`alignBar[
           TypeSystem`NestedGrid`PackagePrivate`$state$$][
           TypeSystem`NestedGrid`PackagePrivate`$bottomBar$$]]}, {
         TypeSystem`NestedGrid`PackagePrivate`$topBar$$, 
          TypeSystem`NestedGrid`PackagePrivate`displayScrollBar[
          TypeSystem`NestedGrid`PackagePrivate`$grid$$, 
           TypeSystem`NestedGrid`PackagePrivate`$state$$, 
           TypeSystem`NestedGrid`PackagePrivate`$pos$$], 
          TypeSystem`NestedGrid`PackagePrivate`onDesktopShow[
           TypeSystem`NestedGrid`PackagePrivate`alignBar[
           TypeSystem`NestedGrid`PackagePrivate`$state$$][
           TypeSystem`NestedGrid`PackagePrivate`$bottomBar$$]]}], Spacings -> 
        If[TypeSystem`NestedGrid`PackagePrivate`$path$$ == {}, 
          0, {{}, {0, 0.05, 0}}]], StandardForm], 
      ImageSizeCache -> {81., {43.134033203125, 48.865966796875}}, 
      TrackedSymbols :> {
       TypeSystem`NestedGrid`PackagePrivate`$state$$, 
        TypeSystem`NestedGrid`PackagePrivate`$grid$$}], 
     BaseStyle -> {LineBreakWithin -> False}, Deinitialization :> 
     TypeSystem`NestedGrid`PackagePrivate`deleteState[
      TypeSystem`NestedGrid`PackagePrivate`$state$$], 
     DynamicModuleValues :> {}, Initialization :> 
     Block[{$ContextPath = $ContextPath}, 
       Needs["TypeSystem`"]]], Deploy, DefaultBaseStyle -> "Deploy"]},
  "CopyTag",
  DisplayFunction->(#& ),
  InterpretationFunction->("Dataset[<>]"& )]], "Output",
 CellChangeTimes->{3.7983801852633867`*^9, 3.798385931187495*^9},
 CellLabel->"Out[55]="]
}, Open  ]],

Cell[BoxData[
 DynamicModuleBox[{MOOCNotebook`Quiz`Private`ans$$ = 0}, 
  InterpretationBox[
   StyleBox[GridBox[{
      {GridBox[{
         {
          
          RadioButtonBox[Dynamic[
           MOOCNotebook`Quiz`Private`ans$$, (
            MOOCNotebook`Quiz`Private`ans$$ = #; SetOptions[
              EvaluationNotebook[], 
              TaggingRules -> {"Answers" -> Flatten[{ToString[1] -> #, 
                   DeleteCases[
                    CurrentValue[
                    EvaluationNotebook[], {TaggingRules, "Answers"}], 
                    ToString[1] -> Blank[]]}]}])& ], {1},
           BaselinePosition->Baseline,
           DefaultBaseStyle->"RadioButtonBar"], 
          StyleBox[
           TemplateBox[{
             StyleBox["\" \"", "ProblemChoiceText", StripOnInput -> False], 
             StyleBox[
              Cell[
               TextData[{
                 StyleBox["Normal[data] ", "InlineFormula"]}]], 
              "ProblemChoiceText", StripOnInput -> False]},
            "RowDefault"], "RadioButtonBarLabel",
           StripOnInput->False]}
        },
        AutoDelete->False,
        BaselinePosition->{1, 2},
        GridBoxAlignment->{"Columns" -> {{Left}}, "Rows" -> {{Baseline}}},
        GridBoxItemSize->{"Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}},
        GridBoxSpacings->{"Columns" -> {
            Offset[0.27999999999999997`], {
             Offset[0.21]}, 
            Offset[0.27999999999999997`]}, "Rows" -> {
            Offset[0.2], {
             Offset[0.4]}, 
            Offset[0.2]}}]},
      {GridBox[{
         {
          
          RadioButtonBox[Dynamic[
           MOOCNotebook`Quiz`Private`ans$$, (
            MOOCNotebook`Quiz`Private`ans$$ = #; SetOptions[
              EvaluationNotebook[], 
              TaggingRules -> {"Answers" -> Flatten[{ToString[1] -> #, 
                   DeleteCases[
                    CurrentValue[
                    EvaluationNotebook[], {TaggingRules, "Answers"}], 
                    ToString[1] -> Blank[]]}]}])& ], {2},
           BaselinePosition->Baseline,
           DefaultBaseStyle->"RadioButtonBar"], 
          StyleBox[
           TemplateBox[{
             StyleBox["\" \"", "ProblemChoiceText", StripOnInput -> False], 
             StyleBox[
              Cell[
               TextData[{
                 StyleBox["Association[data]", "InlineFormula"]}]], 
              "ProblemChoiceText", StripOnInput -> False]},
            "RowDefault"], "RadioButtonBarLabel",
           StripOnInput->False]}
        },
        AutoDelete->False,
        BaselinePosition->{1, 2},
        GridBoxAlignment->{"Columns" -> {{Left}}, "Rows" -> {{Baseline}}},
        GridBoxItemSize->{"Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}},
        GridBoxSpacings->{"Columns" -> {
            Offset[0.27999999999999997`], {
             Offset[0.21]}, 
            Offset[0.27999999999999997`]}, "Rows" -> {
            Offset[0.2], {
             Offset[0.4]}, 
            Offset[0.2]}}]},
      {GridBox[{
         {
          
          RadioButtonBox[Dynamic[
           MOOCNotebook`Quiz`Private`ans$$, (
            MOOCNotebook`Quiz`Private`ans$$ = #; SetOptions[
              EvaluationNotebook[], 
              TaggingRules -> {"Answers" -> Flatten[{ToString[1] -> #, 
                   DeleteCases[
                    CurrentValue[
                    EvaluationNotebook[], {TaggingRules, "Answers"}], 
                    ToString[1] -> Blank[]]}]}])& ], {3},
           BaselinePosition->Baseline,
           DefaultBaseStyle->"RadioButtonBar"], 
          StyleBox[
           TemplateBox[{
             StyleBox["\" \"", "ProblemChoiceText", StripOnInput -> False], 
             StyleBox[
              Cell[
               TextData[{
                 StyleBox["ToAssociation[data]", "InlineFormula"]}]], 
              "ProblemChoiceText", StripOnInput -> False]},
            "RowDefault"], "RadioButtonBarLabel",
           StripOnInput->False]}
        },
        AutoDelete->False,
        BaselinePosition->{1, 2},
        GridBoxAlignment->{"Columns" -> {{Left}}, "Rows" -> {{Baseline}}},
        GridBoxItemSize->{"Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}},
        GridBoxSpacings->{"Columns" -> {
            Offset[0.27999999999999997`], {
             Offset[0.21]}, 
            Offset[0.27999999999999997`]}, "Rows" -> {
            Offset[0.2], {
             Offset[0.4]}, 
            Offset[0.2]}}]},
      {GridBox[{
         {
          
          RadioButtonBox[Dynamic[
           MOOCNotebook`Quiz`Private`ans$$, (
            MOOCNotebook`Quiz`Private`ans$$ = #; SetOptions[
              EvaluationNotebook[], 
              TaggingRules -> {"Answers" -> Flatten[{ToString[1] -> #, 
                   DeleteCases[
                    CurrentValue[
                    EvaluationNotebook[], {TaggingRules, "Answers"}], 
                    ToString[1] -> Blank[]]}]}])& ], {4},
           BaselinePosition->Baseline,
           DefaultBaseStyle->"RadioButtonBar"], 
          StyleBox[
           TemplateBox[{
             StyleBox["\" \"", "ProblemChoiceText", StripOnInput -> False], 
             StyleBox[
              Cell[
               TextData[{
                 StyleBox["AssociationQ[data]", "InlineFormula"]}]], 
              "ProblemChoiceText", StripOnInput -> False]},
            "RowDefault"], "RadioButtonBarLabel",
           StripOnInput->False]}
        },
        AutoDelete->False,
        BaselinePosition->{1, 2},
        GridBoxAlignment->{"Columns" -> {{Left}}, "Rows" -> {{Baseline}}},
        GridBoxItemSize->{"Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}},
        GridBoxSpacings->{"Columns" -> {
            Offset[0.27999999999999997`], {
             Offset[0.21]}, 
            Offset[0.27999999999999997`]}, "Rows" -> {
            Offset[0.2], {
             Offset[0.4]}, 
            Offset[0.2]}}]}
     },
     GridBoxAlignment->{"Columns" -> {{Left}}, "Rows" -> {{Baseline}}}], 
    "Deploy"],
   RadioButtonBar[
    Dynamic[
    MOOCNotebook`Quiz`Private`ans$$, (MOOCNotebook`Quiz`Private`ans$$ = #; 
     SetOptions[
       EvaluationNotebook[], 
       TaggingRules -> {"Answers" -> Flatten[{ToString[1] -> #, 
            DeleteCases[
             CurrentValue[
              EvaluationNotebook[], {TaggingRules, "Answers"}], ToString[1] -> 
             Blank[]]}]}])& ], {1 -> Row[{
        Style[" ", "ProblemChoiceText"], 
        Style[
         RawBoxes[
          Cell[
           TextData[{
             StyleBox["Normal[data] ", "InlineFormula"]}]]], 
         "ProblemChoiceText"]}], 2 -> Row[{
        Style[" ", "ProblemChoiceText"], 
        Style[
         RawBoxes[
          Cell[
           TextData[{
             StyleBox["Association[data]", "InlineFormula"]}]]], 
         "ProblemChoiceText"]}], 3 -> Row[{
        Style[" ", "ProblemChoiceText"], 
        Style[
         RawBoxes[
          Cell[
           TextData[{
             StyleBox["ToAssociation[data]", "InlineFormula"]}]]], 
         "ProblemChoiceText"]}], 4 -> Row[{
        Style[" ", "ProblemChoiceText"], 
        Style[
         RawBoxes[
          Cell[
           TextData[{
             StyleBox["AssociationQ[data]", "InlineFormula"]}]]], 
         "ProblemChoiceText"]}]}, Appearance -> "Vertical", BaselinePosition -> 
    Baseline]],
  DynamicModuleValues:>{}]], "ProblemChoiceGrid"],

Cell["Problem 2", "ProblemSectionNoFeedback",
 TaggingRules->{"QuestionNum" -> "2"}],

Cell[TextData[{
 "Which of these inputs will give a dataset showing \
\[OpenCurlyDoubleQuote]tree\[CloseCurlyDoubleQuote], \
\[OpenCurlyDoubleQuote]height\[CloseCurlyDoubleQuote] and \
\[OpenCurlyDoubleQuote]diameter\[CloseCurlyDoubleQuote] for the three entries \
with the smallest value of \[OpenCurlyDoubleQuote]height\
\[CloseCurlyDoubleQuote], using this dataset as the value of ",
 StyleBox["data", "InlineFormula"],
 "?"
}], "ProblemCaption"],

Cell[CellGroupData[{

Cell[BoxData[
 RowBox[{"data", "=", 
  RowBox[{"Dataset", "[", 
   RowBox[{"{", "\[IndentingNewLine]", 
    RowBox[{
     RowBox[{"<|", 
      RowBox[{
       RowBox[{"\"\<tree\>\"", "\[Rule]", "\"\<e\>\""}], ",", 
       RowBox[{"\"\<height\>\"", "\[Rule]", "39"}], ",", 
       RowBox[{"\"\<diameter\>\"", "\[Rule]", "10.3"}]}], "|>"}], ",", 
     "\[IndentingNewLine]", 
     RowBox[{"<|", 
      RowBox[{
       RowBox[{"\"\<tree\>\"", "->", "\"\<a\>\""}], ",", 
       RowBox[{"\"\<height\>\"", "\[Rule]", "30"}], ",", 
       RowBox[{"\"\<diameter\>\"", "\[Rule]", "9.7"}]}], "|>"}], ",", 
     "\[IndentingNewLine]", 
     RowBox[{"<|", 
      RowBox[{
       RowBox[{"\"\<tree\>\"", "\[Rule]", "\"\<f\>\""}], ",", 
       RowBox[{"\"\<height\>\"", "\[Rule]", "32"}], ",", 
       RowBox[{"\"\<diameter\>\"", "\[Rule]", "10.0"}]}], "|>"}], ",", 
     "\[IndentingNewLine]", 
     RowBox[{"<|", 
      RowBox[{
       RowBox[{"\"\<tree\>\"", "->", "\"\<b\>\""}], ",", 
       RowBox[{"\"\<height\>\"", "\[Rule]", "20"}], ",", 
       RowBox[{"\"\<diameter\>\"", "\[Rule]", "6.1"}]}], "|>"}], ",", 
     "\[IndentingNewLine]", 
     RowBox[{"<|", 
      RowBox[{
       RowBox[{"\"\<tree\>\"", "\[Rule]", "\"\<c\>\""}], ",", 
       RowBox[{"\"\<height\>\"", "\[Rule]", "27"}], ",", 
       RowBox[{"\"\<diameter\>\"", "\[Rule]", "8.3"}]}], "|>"}], ",", 
     "\[IndentingNewLine]", 
     RowBox[{"<|", 
      RowBox[{
       RowBox[{"\"\<tree\>\"", "\[Rule]", "\"\<d\>\""}], ",", 
       RowBox[{"\"\<height\>\"", "\[Rule]", "13"}], ",", 
       RowBox[{"\"\<diameter\>\"", "\[Rule]", "5.7"}]}], "|>"}], ",", 
     "\[IndentingNewLine]", 
     RowBox[{"<|", 
      RowBox[{
       RowBox[{"\"\<tree\>\"", "\[Rule]", "\"\<g\>\""}], ",", 
       RowBox[{"\"\<height\>\"", "\[Rule]", "35"}], ",", 
       RowBox[{"\"\<diameter\>\"", "\[Rule]", "10.1"}]}], "|>"}]}], "}"}], 
   "]"}], " "}]], "Input",
 CellChangeTimes->{{3.7929960083638*^9, 3.792996031083253*^9}, {
  3.7929960997291822`*^9, 3.7929961063175755`*^9}, {3.792996434962823*^9, 
  3.792996461611765*^9}, {3.798381667698894*^9, 3.798381998623414*^9}, {
  3.798382244130579*^9, 3.798382245201433*^9}, {3.7983847479797688`*^9, 
  3.798384780959023*^9}},
 CellLabel->"In[203]:="],

Cell[BoxData[
 TagBox[
  TagBox[
   DynamicModuleBox[{TypeSystem`NestedGrid`PackagePrivate`$state$$ = 
    Association["InitialData" -> {
       Association["tree" -> "e", "height" -> 39, "diameter" -> 10.3], 
       Association["tree" -> "a", "height" -> 30, "diameter" -> 9.7], 
       Association["tree" -> "f", "height" -> 32, "diameter" -> 10.], 
       Association["tree" -> "b", "height" -> 20, "diameter" -> 6.1], 
       Association["tree" -> "c", "height" -> 27, "diameter" -> 8.3], 
       Association["tree" -> "d", "height" -> 13, "diameter" -> 5.7], 
       Association["tree" -> "g", "height" -> 35, "diameter" -> 10.1]}, 
     "InitialShape" -> TypeSystem`PackageScope`HeaderShape[
       Association[{All, "tree"} -> 1, {All, "height"} -> 
        1, {All, "diameter"} -> 1], 
       TypeSystem`PackageScope`Limited[
        TypeSystem`PackageScope`ColumnShape[
         TypeSystem`PackageScope`Limited[
          TypeSystem`PackageScope`RowShape[
           Association[
           "tree" -> TypeSystem`PackageScope`AtomShape[28.800000000000004`], 
            "height" -> TypeSystem`PackageScope`AtomShape[34], "diameter" -> 
            TypeSystem`PackageScope`AtomShape[60]]], 
          DirectedInfinity[1], 3, {All}]], 7, 
        DirectedInfinity[1], {}]], "InitialType" -> TypeSystem`Vector[
       TypeSystem`Struct[{"tree", "height", "diameter"}, {
         TypeSystem`Atom[String], 
         TypeSystem`Atom[Integer], 
         TypeSystem`Atom[Real]}], 7], "Meta" -> 
     Association["ID" -> 73203624039766], "RowTarget" -> 20, "ColumnTarget" -> 
     10, "Shape" -> TypeSystem`PackageScope`HeaderShape[
       Association[{All, "tree"} -> 1, {All, "height"} -> 
        1, {All, "diameter"} -> 1], 
       TypeSystem`PackageScope`Limited[
        TypeSystem`PackageScope`ColumnShape[
         TypeSystem`PackageScope`Limited[
          TypeSystem`PackageScope`RowShape[
           Association[
           "tree" -> TypeSystem`PackageScope`AtomShape[28.800000000000004`], 
            "height" -> TypeSystem`PackageScope`AtomShape[34], "diameter" -> 
            TypeSystem`PackageScope`AtomShape[60]]], 
          DirectedInfinity[1], 3, {All}]], 7, 
        DirectedInfinity[1], {}]], "Type" -> TypeSystem`Vector[
       TypeSystem`Struct[{"tree", "height", "diameter"}, {
         TypeSystem`Atom[String], 
         TypeSystem`Atom[Integer], 
         TypeSystem`Atom[Real]}], 7], "Path" -> {}, "BaseIndices" -> {}, 
     "DisplayedRowCount" -> 7, "DisplayedColumnCount" -> 3, "DataRowCount" -> 
     7, "DataColumnCount" -> 3, "SortPaths" -> {}, "SortDirections" -> {}, 
     "HiddenItemsMap" -> Null, "UpdateType" -> 1], 
    TypeSystem`NestedGrid`PackagePrivate`$outputID$$, 
    TypeSystem`NestedGrid`PackagePrivate`$path$$ = {}, 
    TypeSystem`NestedGrid`PackagePrivate`$vPos$$ = 1, 
    TypeSystem`NestedGrid`PackagePrivate`$hPos$$ = 1, 
    TypeSystem`NestedGrid`PackagePrivate`$grid$$ = 
    DynamicModule[{
     TypeSystem`NestedGrid`PackagePrivate`renderedGrid = Deploy[
        Style[
         Grid[{{
            Item[
             Pane[
              Row[{
                Annotation[
                 EventHandler[
                  MouseAppearance[
                   Mouseover["tree", 
                    Style[
                    "tree", FontColor -> 
                    RGBColor[
                    0.27450980392156865`, 0.5372549019607843, 
                    0.792156862745098]]], "LinkHand"], {"MouseClicked", 1} :> 
                  TypeSystem`NestedGrid`PackagePrivate`updateState[
                   TypeSystem`NestedGrid`PackagePrivate`$state$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$path$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$vPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$hPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$grid$$, 
                    TypeSystem`NestedGrid`PackagePrivate`localHold[
                    TypeSystem`NestedGrid`PackagePrivate`localHold[
                    TypeSystem`NestedGrid`PackagePrivate`$outputID$$]]][{
                    All, "tree"}, 1]], 
                 TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                  TypeSystem`NestedGrid`PackagePrivate`localHold[
                  TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{
                  All, "tree"}, "ColumnHeader", True], "Mouse"], " ", ""}], 
              ImageSize -> {{1, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], Background -> 
             GrayLevel[0.95], Alignment -> {Left, Baseline}], 
            Item[
             Pane[
              Row[{
                Annotation[
                 EventHandler[
                  MouseAppearance[
                   Mouseover["height", 
                    Style[
                    "height", FontColor -> 
                    RGBColor[
                    0.27450980392156865`, 0.5372549019607843, 
                    0.792156862745098]]], "LinkHand"], {"MouseClicked", 1} :> 
                  TypeSystem`NestedGrid`PackagePrivate`updateState[
                   TypeSystem`NestedGrid`PackagePrivate`$state$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$path$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$vPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$hPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$grid$$, 
                    TypeSystem`NestedGrid`PackagePrivate`localHold[
                    TypeSystem`NestedGrid`PackagePrivate`localHold[
                    TypeSystem`NestedGrid`PackagePrivate`$outputID$$]]][{
                    All, "height"}, 1]], 
                 TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                  TypeSystem`NestedGrid`PackagePrivate`localHold[
                  TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{
                  All, "height"}, "ColumnHeader", True], "Mouse"], " ", ""}], 
              ImageSize -> {{1, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], Background -> 
             GrayLevel[0.95], Alignment -> {Left, Baseline}], 
            Item[
             Pane[
              Row[{
                Annotation[
                 EventHandler[
                  MouseAppearance[
                   Mouseover["diameter", 
                    Style[
                    "diameter", FontColor -> 
                    RGBColor[
                    0.27450980392156865`, 0.5372549019607843, 
                    0.792156862745098]]], "LinkHand"], {"MouseClicked", 1} :> 
                  TypeSystem`NestedGrid`PackagePrivate`updateState[
                   TypeSystem`NestedGrid`PackagePrivate`$state$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$path$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$vPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$hPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$grid$$, 
                    TypeSystem`NestedGrid`PackagePrivate`localHold[
                    TypeSystem`NestedGrid`PackagePrivate`localHold[
                    TypeSystem`NestedGrid`PackagePrivate`$outputID$$]]][{
                    All, "diameter"}, 1]], 
                 TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                  TypeSystem`NestedGrid`PackagePrivate`localHold[
                  TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{
                  All, "diameter"}, "ColumnHeader", True], "Mouse"], " ", 
                ""}], ImageSize -> {{1, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], Background -> 
             GrayLevel[0.95], Alignment -> {Left, Baseline}]}, {
            Item[
             Pane[
              Annotation["e", 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{1, 
                 Key["tree"]}, "Item", False], "Mouse"], 
              ImageSize -> {{28.800000000000004`, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["39"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{1, 
                 Key["height"]}, "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["10.3"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{1, 
                 Key["diameter"]}, "Item", False], "Mouse"], 
              ImageSize -> {{60, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}]}, {
            Item[
             Pane[
              Annotation["a", 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{2, 
                 Key["tree"]}, "Item", False], "Mouse"], 
              ImageSize -> {{28.800000000000004`, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["30"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{2, 
                 Key["height"]}, "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["9.7"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{2, 
                 Key["diameter"]}, "Item", False], "Mouse"], 
              ImageSize -> {{60, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}]}, {
            Item[
             Pane[
              Annotation["f", 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{3, 
                 Key["tree"]}, "Item", False], "Mouse"], 
              ImageSize -> {{28.800000000000004`, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["32"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{3, 
                 Key["height"]}, "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["10.0"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{3, 
                 Key["diameter"]}, "Item", False], "Mouse"], 
              ImageSize -> {{60, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}]}, {
            Item[
             Pane[
              Annotation["b", 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{4, 
                 Key["tree"]}, "Item", False], "Mouse"], 
              ImageSize -> {{28.800000000000004`, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["20"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{4, 
                 Key["height"]}, "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["6.1"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{4, 
                 Key["diameter"]}, "Item", False], "Mouse"], 
              ImageSize -> {{60, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}]}, {
            Item[
             Pane[
              Annotation["c", 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{5, 
                 Key["tree"]}, "Item", False], "Mouse"], 
              ImageSize -> {{28.800000000000004`, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["27"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{5, 
                 Key["height"]}, "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["8.3"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{5, 
                 Key["diameter"]}, "Item", False], "Mouse"], 
              ImageSize -> {{60, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}]}, {
            Item[
             Pane[
              Annotation["d", 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{6, 
                 Key["tree"]}, "Item", False], "Mouse"], 
              ImageSize -> {{28.800000000000004`, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["13"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{6, 
                 Key["height"]}, "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["5.7"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{6, 
                 Key["diameter"]}, "Item", False], "Mouse"], 
              ImageSize -> {{60, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}]}, {
            Item[
             Pane[
              Annotation["g", 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{7, 
                 Key["tree"]}, "Item", False], "Mouse"], 
              ImageSize -> {{28.800000000000004`, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["35"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{7, 
                 Key["height"]}, "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["10.1"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{7, 
                 Key["diameter"]}, "Item", False], "Mouse"], 
              ImageSize -> {{60, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}]}}, 
          BaseStyle -> {
           ContextMenu -> 
            Dynamic[TypeSystem`NestedGrid`PackagePrivate`$contextMenuTrigger; 
              Which[TypeSystem`NestedGrid`PackagePrivate`$lastOutputID =!= 
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                 TypeSystem`NestedGrid`PackagePrivate`$outputID$$], {}, 
                TypeSystem`NestedGrid`PackagePrivate`$contextMenuTrigger === 
                TypeSystem`NestedGrid`PackagePrivate`$lastContextMenuTrigger, 
                TypeSystem`NestedGrid`PackagePrivate`$lastContextMenu, True, 
                TypeSystem`NestedGrid`PackagePrivate`$lastContextMenuTrigger = 
                 TypeSystem`NestedGrid`PackagePrivate`$contextMenuTrigger; 
                TypeSystem`NestedGrid`PackagePrivate`$lastContextMenu = 
                 Block[{TypeSystem`NestedGrid`PackagePrivate`$globalScrollPos = \
{TypeSystem`NestedGrid`PackagePrivate`$vPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$hPos$$}}, 
                   
                   With[{TypeSystem`NestedGrid`PackagePrivate`lastPath$ = 
                    TypeSystem`NestedGrid`PackagePrivate`$lastPath, 
                    TypeSystem`NestedGrid`PackagePrivate`lastPathType$ = 
                    TypeSystem`NestedGrid`PackagePrivate`$lastPathType, 
                    TypeSystem`NestedGrid`PackagePrivate`isLeafHeader$ = 
                    TypeSystem`NestedGrid`PackagePrivate`$\
lastPathIsLeafHeader, TypeSystem`NestedGrid`PackagePrivate`allHidden$ = 
                    TypeSystem`NestedGrid`PackagePrivate`allHiddenQ[
                    TypeSystem`NestedGrid`PackagePrivate`$lastPath, 
                    TypeSystem`NestedGrid`PackagePrivate`$state$$], 
                    TypeSystem`NestedGrid`PackagePrivate`anyHidden$ = 
                    TypeSystem`NestedGrid`PackagePrivate`anyHiddenQ[
                    TypeSystem`NestedGrid`PackagePrivate`$lastPath, 
                    TypeSystem`NestedGrid`PackagePrivate`$state$$], 
                    TypeSystem`NestedGrid`PackagePrivate`sortDirection$ = 
                    TypeSystem`NestedGrid`PackagePrivate`columnSortDirection[
                    TypeSystem`NestedGrid`PackagePrivate`$lastPath, 
                    TypeSystem`NestedGrid`PackagePrivate`$state$$[
                    "SortPaths"], 
                    TypeSystem`NestedGrid`PackagePrivate`$state$$[
                    "SortDirections"]], 
                    TypeSystem`NestedGrid`PackagePrivate`haveData$ = Not[
                    FailureQ[
                    TypeSystem`NestedGrid`PackagePrivate`datasetInitialData[
                    TypeSystem`NestedGrid`PackagePrivate`$state$$]]], 
                    TypeSystem`NestedGrid`PackagePrivate`isKeyDummy$ = Not[
                    FreeQ[
                    TypeSystem`NestedGrid`PackagePrivate`$lastPath, Keys]]}, 
                    Join[{
                    If[
                    Or[
                    Not[TypeSystem`NestedGrid`PackagePrivate`haveData$], 
                    Not[TypeSystem`NestedGrid`PackagePrivate`anyHidden$], 
                    TypeSystem`NestedGrid`PackagePrivate`isKeyDummy$], 
                    Nothing, 
                    MenuItem[
                    StringJoin["Show ", 
                    Which[
                    TypeSystem`NestedGrid`PackagePrivate`lastPathType$ == 
                    "Item", "", 
                    TypeSystem`NestedGrid`PackagePrivate`allHidden$, 
                    ToString[
                    ReplaceAll[
                    Last[TypeSystem`NestedGrid`PackagePrivate`lastPath$], 
                    Key[
                    Pattern[TypeSystem`NestedGrid`PackagePrivate`x, 
                    Blank[]]] :> TypeSystem`NestedGrid`PackagePrivate`x]], 
                    TypeSystem`NestedGrid`PackagePrivate`lastPathType$ == 
                    "RowHeader", "Row", 
                    TypeSystem`NestedGrid`PackagePrivate`lastPathType$ == 
                    "ColumnHeader", "Column", True, ""]], 
                    KernelExecute[
                    TypeSystem`NestedGrid`PackagePrivate`updateHiddenItems[
                    TypeSystem`NestedGrid`PackagePrivate`$state$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$path$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$vPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$hPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$grid$$, 
                    TypeSystem`NestedGrid`PackagePrivate`localHold[
                    TypeSystem`NestedGrid`PackagePrivate`localHold[
                    TypeSystem`NestedGrid`PackagePrivate`$outputID$$]]][
                    TypeSystem`NestedGrid`PackagePrivate`lastPath$, 
                    "remove"]], MenuEvaluator -> Automatic]], 
                    If[
                    Or[
                    Not[TypeSystem`NestedGrid`PackagePrivate`haveData$], 
                    TypeSystem`NestedGrid`PackagePrivate`pathEmptyQ[
                    TypeSystem`NestedGrid`PackagePrivate`$lastPath, 
                    TypeSystem`NestedGrid`PackagePrivate`$state$$], 
                    TypeSystem`NestedGrid`PackagePrivate`allHidden$, 
                    TypeSystem`NestedGrid`PackagePrivate`isKeyDummy$], 
                    Nothing, 
                    MenuItem[
                    StringJoin["Hide ", 
                    Which[
                    TypeSystem`NestedGrid`PackagePrivate`lastPathType$ == 
                    "Item", "", 
                    TypeSystem`NestedGrid`PackagePrivate`allHidden$, 
                    ToString[
                    ReplaceAll[
                    Last[TypeSystem`NestedGrid`PackagePrivate`lastPath$], 
                    Key[
                    Pattern[TypeSystem`NestedGrid`PackagePrivate`x, 
                    Blank[]]] :> TypeSystem`NestedGrid`PackagePrivate`x]], 
                    TypeSystem`NestedGrid`PackagePrivate`lastPathType$ == 
                    "RowHeader", "Row", 
                    TypeSystem`NestedGrid`PackagePrivate`lastPathType$ == 
                    "ColumnHeader", "Column", True, ""]], 
                    KernelExecute[
                    TypeSystem`NestedGrid`PackagePrivate`updateHiddenItems[
                    TypeSystem`NestedGrid`PackagePrivate`$state$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$path$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$vPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$hPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$grid$$, 
                    TypeSystem`NestedGrid`PackagePrivate`localHold[
                    TypeSystem`NestedGrid`PackagePrivate`localHold[
                    TypeSystem`NestedGrid`PackagePrivate`$outputID$$]]][
                    TypeSystem`NestedGrid`PackagePrivate`lastPath$, "add"]], 
                    MenuEvaluator -> Automatic]], Delimiter}, 
                    If[
                    And[TypeSystem`NestedGrid`PackagePrivate`haveData$, 
                    MatchQ[TypeSystem`NestedGrid`PackagePrivate`lastPathType$, 
                    Alternatives["ColumnHeader", "KeyDummy"]], 
                    TypeSystem`NestedGrid`PackagePrivate`isLeafHeader$, 
                    Not[TypeSystem`NestedGrid`PackagePrivate`allHidden$]], {
                    If[
                    TypeSystem`NestedGrid`PackagePrivate`sortDirection$ =!= 
                    "Ascending", 
                    MenuItem["Sort", 
                    KernelExecute[
                    TypeSystem`NestedGrid`PackagePrivate`updateSort[
                    TypeSystem`NestedGrid`PackagePrivate`$state$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$path$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$vPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$hPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$grid$$, 
                    TypeSystem`NestedGrid`PackagePrivate`localHold[
                    TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][
                    TypeSystem`NestedGrid`PackagePrivate`lastPath$, 
                    "Ascending"]], MenuEvaluator -> Automatic], Nothing], 
                    If[
                    TypeSystem`NestedGrid`PackagePrivate`sortDirection$ =!= 
                    "Descending", 
                    MenuItem["Reverse Sort", 
                    KernelExecute[
                    TypeSystem`NestedGrid`PackagePrivate`updateSort[
                    TypeSystem`NestedGrid`PackagePrivate`$state$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$path$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$vPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$hPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$grid$$, 
                    TypeSystem`NestedGrid`PackagePrivate`localHold[
                    TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][
                    TypeSystem`NestedGrid`PackagePrivate`lastPath$, 
                    "Descending"]], MenuEvaluator -> Automatic], Nothing], 
                    If[
                    TypeSystem`NestedGrid`PackagePrivate`sortDirection$ =!= 
                    None, 
                    MenuItem["Unsort", 
                    KernelExecute[
                    TypeSystem`NestedGrid`PackagePrivate`updateSort[
                    TypeSystem`NestedGrid`PackagePrivate`$state$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$path$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$vPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$hPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$grid$$, 
                    TypeSystem`NestedGrid`PackagePrivate`localHold[
                    TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][
                    TypeSystem`NestedGrid`PackagePrivate`lastPath$, None]], 
                    MenuEvaluator -> Automatic], Nothing], Delimiter}, {}], {
                    MenuItem["Copy Position to Clipboard", 
                    KernelExecute[
                    TypeSystem`NestedGrid`PackagePrivate`toCurrentPosition[
                    TypeSystem`NestedGrid`PackagePrivate`copyClip]], 
                    MenuEvaluator -> Automatic], 
                    MenuItem["Copy Data to Clipboard", 
                    KernelExecute[
                    TypeSystem`NestedGrid`PackagePrivate`toCurrentData[
                    TypeSystem`NestedGrid`PackagePrivate`$state$$, 
                    TypeSystem`NestedGrid`PackagePrivate`copyClip]], 
                    MenuEvaluator -> Automatic], Delimiter, 
                    MenuItem["Paste Position in New Cell", 
                    KernelExecute[
                    TypeSystem`NestedGrid`PackagePrivate`toCurrentPosition[
                    TypeSystem`NestedGrid`PackagePrivate`cellPaste]], 
                    MenuEvaluator -> Automatic], 
                    MenuItem["Paste Data in New Cell", 
                    KernelExecute[
                    TypeSystem`NestedGrid`PackagePrivate`toCurrentData[
                    TypeSystem`NestedGrid`PackagePrivate`$state$$, 
                    TypeSystem`NestedGrid`PackagePrivate`cellPaste]], 
                    MenuEvaluator -> Automatic]}]]]]], FontFamily -> 
            "Verdana", FontSize -> 12}, Spacings -> {0, 0}, Alignment -> Left,
           Dividers -> All, FrameStyle -> GrayLevel[0.7490196078431373], 
          BaseStyle -> {FontFamily -> "Verdana", FontSize -> 12}], 
         LineBreakWithin -> False, ContextMenu -> {}, NumberMarks -> False, 
         ShowAutoStyles -> False]], 
      TypeSystem`NestedGrid`PackagePrivate`initialQ = True}, 
     Dynamic[
      TypeSystem`NestedGrid`PackagePrivate`setupViewPath[
      TypeSystem`NestedGrid`PackagePrivate`$path$$, If[
         Not[TypeSystem`NestedGrid`PackagePrivate`initialQ], 
         Module[{
          TypeSystem`NestedGrid`PackagePrivate`tmpGrid$ = $Failed, 
           TypeSystem`NestedGrid`PackagePrivate`tmpData$ = 
           TypeSystem`NestedGrid`PackagePrivate`datasetData[
            TypeSystem`NestedGrid`PackagePrivate`$state$$]}, 
          TypeSystem`NestedGrid`PackagePrivate`tmpGrid$ = If[
             FailureQ[TypeSystem`NestedGrid`PackagePrivate`tmpData$], 
             TypeSystem`NestedGrid`PackagePrivate`renderedGrid, 
             TypeSystem`NestedGrid`PackagePrivate`renderGrid[
             TypeSystem`NestedGrid`PackagePrivate`$state$$, 
              TypeSystem`NestedGrid`PackagePrivate`$path$$, 
              TypeSystem`NestedGrid`PackagePrivate`$vPos$$, 
              TypeSystem`NestedGrid`PackagePrivate`$hPos$$, 
              TypeSystem`NestedGrid`PackagePrivate`$grid$$, 
              TypeSystem`NestedGrid`PackagePrivate`localHold[
              TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][
             TypeSystem`NestedGrid`PackagePrivate`tmpData$]]; If[
            Not[
             FailureQ[TypeSystem`NestedGrid`PackagePrivate`tmpGrid$]], 
            TypeSystem`NestedGrid`PackagePrivate`renderedGrid = 
            TypeSystem`NestedGrid`PackagePrivate`tmpGrid$]; Null]]; 
       TypeSystem`NestedGrid`PackagePrivate`initialQ = False; 
       TypeSystem`NestedGrid`PackagePrivate`$vPos$$; 
       TypeSystem`NestedGrid`PackagePrivate`$hPos$$; If[
         FailureQ[TypeSystem`NestedGrid`PackagePrivate`renderedGrid], 
         TypeSystem`SparseGrid[
          TypeSystem`H["(data no longer present)"]], 
         If[GeneralUtilities`$DebugMode, 
          Row[{TypeSystem`NestedGrid`PackagePrivate`renderedGrid, "  ", 
            TypeSystem`NestedGrid`PackagePrivate`formatState[
            TypeSystem`NestedGrid`PackagePrivate`$state$$, 
             TypeSystem`NestedGrid`PackagePrivate`$path$$, 
             TypeSystem`NestedGrid`PackagePrivate`$vPos$$, 
             TypeSystem`NestedGrid`PackagePrivate`$hPos$$]}], 
          TypeSystem`NestedGrid`PackagePrivate`renderedGrid]]], 
      TrackedSymbols :> {
       TypeSystem`NestedGrid`PackagePrivate`$vPos$$, 
        TypeSystem`NestedGrid`PackagePrivate`$hPos$$}], 
     DynamicModuleValues :> {}], 
    TypeSystem`NestedGrid`PackagePrivate`$topBar$$ = Dynamic[
     TypeSystem`NestedGrid`PackagePrivate`makeFramedBar[
      TypeSystem`PackageScope`SubViewPathbar[
      TypeSystem`NestedGrid`PackagePrivate`$path$$, 
       TypeSystem`NestedGrid`PackagePrivate`updateState[
       TypeSystem`NestedGrid`PackagePrivate`$state$$, 
        TypeSystem`NestedGrid`PackagePrivate`$path$$, 
        TypeSystem`NestedGrid`PackagePrivate`$vPos$$, 
        TypeSystem`NestedGrid`PackagePrivate`$hPos$$, 
        TypeSystem`NestedGrid`PackagePrivate`$grid$$, 
        TypeSystem`NestedGrid`PackagePrivate`localHold[
        TypeSystem`NestedGrid`PackagePrivate`$outputID$$]]]], 
     TrackedSymbols :> {TypeSystem`NestedGrid`PackagePrivate`$path$$}], 
    TypeSystem`NestedGrid`PackagePrivate`$bottomBar$$ = Style[
     Framed[
      Dynamic[
       Replace[
       TypeSystem`NestedGrid`PackagePrivate`mouseAnnotation$$, {
        TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
           TypeSystem`NestedGrid`PackagePrivate`localHold[
           TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][Null, 
           Blank[]] -> "", TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
           TypeSystem`NestedGrid`PackagePrivate`localHold[
           TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][
           Pattern[TypeSystem`NestedGrid`PackagePrivate`path$, 
            Blank[]], 
           Pattern[TypeSystem`NestedGrid`PackagePrivate`pathType$, 
            Blank[]], 
           Pattern[TypeSystem`NestedGrid`PackagePrivate`isLeafHeader$, 
            Blank[]]] :> (
          Increment[TypeSystem`NestedGrid`PackagePrivate`$contextMenuTrigger]; 
          TypeSystem`NestedGrid`PackagePrivate`$lastPath = 
           TypeSystem`NestedGrid`PackagePrivate`path$; 
          TypeSystem`NestedGrid`PackagePrivate`$lastPathType = 
           TypeSystem`NestedGrid`PackagePrivate`pathType$; 
          TypeSystem`NestedGrid`PackagePrivate`$lastPathIsLeafHeader = 
           TypeSystem`NestedGrid`PackagePrivate`isLeafHeader$; 
          TypeSystem`NestedGrid`PackagePrivate`$lastOutputID = 
           TypeSystem`NestedGrid`PackagePrivate`localHold[
            TypeSystem`NestedGrid`PackagePrivate`$outputID$$]; 
          TypeSystem`NestedGrid`PackagePrivate`makePathTrail[
           TypeSystem`NestedGrid`PackagePrivate`path$, 
            TypeSystem`NestedGrid`PackagePrivate`makePathElements]), Null :> 
         Spacer[10], Blank[] :> Spacer[10]}], 
       TrackedSymbols :> {
        TypeSystem`NestedGrid`PackagePrivate`mouseAnnotation$$}], FrameStyle -> 
      None, ImageMargins -> 0, FrameMargins -> 0, Alignment -> Top, 
      ImageSize -> {Automatic, 15}], FontSize -> 1], 
    TypeSystem`NestedGrid`PackagePrivate`mouseAnnotation$$ = Null}, 
    DynamicWrapperBox[
     DynamicBox[ToBoxes[
       Dataset`DatasetContent[
       1, "Path" -> TypeSystem`NestedGrid`PackagePrivate`$path$$, "Grid" -> 
        TypeSystem`NestedGrid`PackagePrivate`releaseLocalHold[
         TypeSystem`NestedGrid`PackagePrivate`$grid$$], "State" -> 
        TypeSystem`NestedGrid`PackagePrivate`$state$$, "VPos" -> 
        Hold[TypeSystem`NestedGrid`PackagePrivate`$vPos$$], "HPos" -> 
        Hold[TypeSystem`NestedGrid`PackagePrivate`$hPos$$], "TopBar" -> 
        TypeSystem`NestedGrid`PackagePrivate`$topBar$$, "BottomBar" -> 
        TypeSystem`NestedGrid`PackagePrivate`releaseLocalHold[
         TypeSystem`NestedGrid`PackagePrivate`$bottomBar$$]], StandardForm],
      ImageSizeCache->{172., {115.634033203125, 121.365966796875}},
      TrackedSymbols:>{
       TypeSystem`NestedGrid`PackagePrivate`$state$$, 
        TypeSystem`NestedGrid`PackagePrivate`$grid$$}], 
     TypeSystem`NestedGrid`PackagePrivate`mouseAnnotation$$ = 
     MouseAnnotation[],
     ImageSizeCache->{172., {115.634033203125, 121.365966796875}}],
    BaseStyle->{LineBreakWithin -> False},
    DynamicModuleValues:>{},
    Initialization:>
     Block[{$ContextPath = $ContextPath}, Needs["TypeSystem`"]; 
      Needs["Dataset`"]; 
      TypeSystem`NestedGrid`PackagePrivate`$outputID$$ = CreateUUID[]],
    UnsavedVariables:>{TypeSystem`NestedGrid`PackagePrivate`$outputID$$}],
   Deploy,
   DefaultBaseStyle->"Deploy"],
  Dataset`InterpretDataset[1],
  Editable->False,
  SelectWithContents->True,
  Selectable->False]], "Output",
 CellChangeTimes->{
  3.798381628197051*^9, 3.798381896860504*^9, 3.7983819988597517`*^9, 
   3.798382295945113*^9, 3.798384643830608*^9, {3.798384761375052*^9, 
   3.7983847824710093`*^9}, 3.798987941618598*^9},
 CellLabel->"Out[203]="]
}, Open  ]],

Cell[BoxData[
 DynamicModuleBox[{MOOCNotebook`Quiz`Private`ans$$ = 0}, 
  InterpretationBox[
   StyleBox[GridBox[{
      {GridBox[{
         {
          
          RadioButtonBox[Dynamic[
           MOOCNotebook`Quiz`Private`ans$$, (
            MOOCNotebook`Quiz`Private`ans$$ = #; SetOptions[
              EvaluationNotebook[], 
              TaggingRules -> {"Answers" -> Flatten[{ToString[2] -> #, 
                   DeleteCases[
                    CurrentValue[
                    EvaluationNotebook[], {TaggingRules, "Answers"}], 
                    ToString[2] -> Blank[]]}]}])& ], {1},
           BaselinePosition->Baseline,
           DefaultBaseStyle->"RadioButtonBar"], 
          StyleBox[
           TemplateBox[{
             StyleBox["\" \"", "ProblemChoiceText", StripOnInput -> False], 
             StyleBox[
              Cell[
               TextData[{
                 StyleBox[
                 "data[TakeSmallestBy[\"height\",3]]", "InlineFormula"]}]], 
              "ProblemChoiceText", StripOnInput -> False]},
            "RowDefault"], "RadioButtonBarLabel",
           StripOnInput->False]}
        },
        AutoDelete->False,
        BaselinePosition->{1, 2},
        GridBoxAlignment->{"Columns" -> {{Left}}, "Rows" -> {{Baseline}}},
        GridBoxItemSize->{"Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}},
        GridBoxSpacings->{"Columns" -> {
            Offset[0.27999999999999997`], {
             Offset[0.21]}, 
            Offset[0.27999999999999997`]}, "Rows" -> {
            Offset[0.2], {
             Offset[0.4]}, 
            Offset[0.2]}}]},
      {GridBox[{
         {
          
          RadioButtonBox[Dynamic[
           MOOCNotebook`Quiz`Private`ans$$, (
            MOOCNotebook`Quiz`Private`ans$$ = #; SetOptions[
              EvaluationNotebook[], 
              TaggingRules -> {"Answers" -> Flatten[{ToString[2] -> #, 
                   DeleteCases[
                    CurrentValue[
                    EvaluationNotebook[], {TaggingRules, "Answers"}], 
                    ToString[2] -> Blank[]]}]}])& ], {2},
           BaselinePosition->Baseline,
           DefaultBaseStyle->"RadioButtonBar"], 
          StyleBox[
           TemplateBox[{
             StyleBox["\" \"", "ProblemChoiceText", StripOnInput -> False], 
             StyleBox[
              Cell[
               TextData[{
                 StyleBox[
                 "TakeSmallestBy[data,\"height\",3]", "InlineFormula"]}]], 
              "ProblemChoiceText", StripOnInput -> False]},
            "RowDefault"], "RadioButtonBarLabel",
           StripOnInput->False]}
        },
        AutoDelete->False,
        BaselinePosition->{1, 2},
        GridBoxAlignment->{"Columns" -> {{Left}}, "Rows" -> {{Baseline}}},
        GridBoxItemSize->{"Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}},
        GridBoxSpacings->{"Columns" -> {
            Offset[0.27999999999999997`], {
             Offset[0.21]}, 
            Offset[0.27999999999999997`]}, "Rows" -> {
            Offset[0.2], {
             Offset[0.4]}, 
            Offset[0.2]}}]},
      {GridBox[{
         {
          
          RadioButtonBox[Dynamic[
           MOOCNotebook`Quiz`Private`ans$$, (
            MOOCNotebook`Quiz`Private`ans$$ = #; SetOptions[
              EvaluationNotebook[], 
              TaggingRules -> {"Answers" -> Flatten[{ToString[2] -> #, 
                   DeleteCases[
                    CurrentValue[
                    EvaluationNotebook[], {TaggingRules, "Answers"}], 
                    ToString[2] -> Blank[]]}]}])& ], {3},
           BaselinePosition->Baseline,
           DefaultBaseStyle->"RadioButtonBar"], 
          StyleBox[
           TemplateBox[{
             StyleBox["\" \"", "ProblemChoiceText", StripOnInput -> False], 
             StyleBox[
              Cell[
               TextData[{
                 StyleBox[
                 "SortBy[data,\"height\"][[1;;3]]", "InlineFormula"]}]], 
              "ProblemChoiceText", StripOnInput -> False]},
            "RowDefault"], "RadioButtonBarLabel",
           StripOnInput->False]}
        },
        AutoDelete->False,
        BaselinePosition->{1, 2},
        GridBoxAlignment->{"Columns" -> {{Left}}, "Rows" -> {{Baseline}}},
        GridBoxItemSize->{"Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}},
        GridBoxSpacings->{"Columns" -> {
            Offset[0.27999999999999997`], {
             Offset[0.21]}, 
            Offset[0.27999999999999997`]}, "Rows" -> {
            Offset[0.2], {
             Offset[0.4]}, 
            Offset[0.2]}}]},
      {GridBox[{
         {
          
          RadioButtonBox[Dynamic[
           MOOCNotebook`Quiz`Private`ans$$, (
            MOOCNotebook`Quiz`Private`ans$$ = #; SetOptions[
              EvaluationNotebook[], 
              TaggingRules -> {"Answers" -> Flatten[{ToString[2] -> #, 
                   DeleteCases[
                    CurrentValue[
                    EvaluationNotebook[], {TaggingRules, "Answers"}], 
                    ToString[2] -> Blank[]]}]}])& ], {4},
           BaselinePosition->Baseline,
           DefaultBaseStyle->"RadioButtonBar"], 
          StyleBox[
           TemplateBox[{
             StyleBox["\" \"", "ProblemChoiceText", StripOnInput -> False], 
             StyleBox[
              Cell["All of the above"], "ProblemChoiceText", StripOnInput -> 
              False]},
            "RowDefault"], "RadioButtonBarLabel",
           StripOnInput->False]}
        },
        AutoDelete->False,
        BaselinePosition->{1, 2},
        GridBoxAlignment->{"Columns" -> {{Left}}, "Rows" -> {{Baseline}}},
        GridBoxItemSize->{"Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}},
        GridBoxSpacings->{"Columns" -> {
            Offset[0.27999999999999997`], {
             Offset[0.21]}, 
            Offset[0.27999999999999997`]}, "Rows" -> {
            Offset[0.2], {
             Offset[0.4]}, 
            Offset[0.2]}}]}
     },
     GridBoxAlignment->{"Columns" -> {{Left}}, "Rows" -> {{Baseline}}}], 
    "Deploy"],
   RadioButtonBar[
    Dynamic[
    MOOCNotebook`Quiz`Private`ans$$, (MOOCNotebook`Quiz`Private`ans$$ = #; 
     SetOptions[
       EvaluationNotebook[], 
       TaggingRules -> {"Answers" -> Flatten[{ToString[2] -> #, 
            DeleteCases[
             CurrentValue[
              EvaluationNotebook[], {TaggingRules, "Answers"}], ToString[2] -> 
             Blank[]]}]}])& ], {1 -> Row[{
        Style[" ", "ProblemChoiceText"], 
        Style[
         RawBoxes[
          Cell[
           TextData[{
             StyleBox[
             "data[TakeSmallestBy[\"height\",3]]", "InlineFormula"]}]]], 
         "ProblemChoiceText"]}], 2 -> Row[{
        Style[" ", "ProblemChoiceText"], 
        Style[
         RawBoxes[
          Cell[
           TextData[{
             StyleBox[
             "TakeSmallestBy[data,\"height\",3]", "InlineFormula"]}]]], 
         "ProblemChoiceText"]}], 3 -> Row[{
        Style[" ", "ProblemChoiceText"], 
        Style[
         RawBoxes[
          Cell[
           TextData[{
             StyleBox["SortBy[data,\"height\"][[1;;3]]", "InlineFormula"]}]]],
          "ProblemChoiceText"]}], 4 -> Row[{
        Style[" ", "ProblemChoiceText"], 
        Style[
         RawBoxes[
          Cell["All of the above"]], "ProblemChoiceText"]}]}, Appearance -> 
    "Vertical", BaselinePosition -> Baseline]],
  DynamicModuleValues:>{}]], "ProblemChoiceGrid"],

Cell["Problem 3", "ProblemSectionNoFeedback",
 TaggingRules->{"QuestionNum" -> "3"}],

Cell[TextData[{
 "Which of these inputs will give a new dataset consisting of the last two \
rows of the dataset in this value of ",
 StyleBox["data", "InlineFormula"],
 "?"
}], "ProblemCaption"],

Cell[CellGroupData[{

Cell[BoxData[
 RowBox[{"data", "=", 
  RowBox[{"Dataset", "[", 
   RowBox[{"{", 
    RowBox[{
     RowBox[{"{", 
      RowBox[{"1", ",", "1", ",", "7", ",", "0"}], "}"}], ",", 
     RowBox[{"{", 
      RowBox[{"5", ",", "6", ",", "7", ",", "8"}], "}"}], ",", 
     RowBox[{"{", 
      RowBox[{"2", ",", "4", ",", "6", ",", "2"}], "}"}], ",", 
     RowBox[{"{", 
      RowBox[{"5", ",", "8", ",", "8", ",", "3"}], "}"}]}], "}"}], 
   "]"}]}]], "Input",
 CellChangeTimes->{{3.798386126161674*^9, 3.7983861306918573`*^9}},
 CellLabel->"In[207]:="],

Cell[BoxData[
 TagBox[
  TagBox[
   DynamicModuleBox[{TypeSystem`NestedGrid`PackagePrivate`$state$$ = 
    Association[
    "InitialData" -> {{1, 1, 7, 0}, {5, 6, 7, 8}, {2, 4, 6, 2}, {5, 8, 8, 3}},
      "InitialShape" -> TypeSystem`PackageScope`Limited[
       TypeSystem`PackageScope`MatrixShape[4, 4], 4, 4, {All}], "InitialType" -> 
     TypeSystem`Vector[
       TypeSystem`Vector[
        TypeSystem`Atom[Integer], 4], 4], "Meta" -> 
     Association["ID" -> 73225098876269], "RowTarget" -> 20, "ColumnTarget" -> 
     10, "Shape" -> TypeSystem`PackageScope`Limited[
       TypeSystem`PackageScope`MatrixShape[4, 4], 4, 4, {All}], "Type" -> 
     TypeSystem`Vector[
       TypeSystem`Vector[
        TypeSystem`Atom[Integer], 4], 4], "Path" -> {}, "BaseIndices" -> {}, 
     "DisplayedRowCount" -> 4, "DisplayedColumnCount" -> 4, "DataRowCount" -> 
     4, "DataColumnCount" -> 4, "SortPaths" -> {}, "SortDirections" -> {}, 
     "HiddenItemsMap" -> Null, "UpdateType" -> 1], 
    TypeSystem`NestedGrid`PackagePrivate`$outputID$$, 
    TypeSystem`NestedGrid`PackagePrivate`$path$$ = {}, 
    TypeSystem`NestedGrid`PackagePrivate`$vPos$$ = 1, 
    TypeSystem`NestedGrid`PackagePrivate`$hPos$$ = 1, 
    TypeSystem`NestedGrid`PackagePrivate`$grid$$ = 
    DynamicModule[{
     TypeSystem`NestedGrid`PackagePrivate`renderedGrid = Deploy[
        Style[
         Grid[{{
            Item[
             Pane[
              Annotation[
               RawBoxes["1"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{1, 1}, 
                "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["1"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{1, 2}, 
                "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["7"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{1, 3}, 
                "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["0"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{1, 4}, 
                "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}]}, {
            Item[
             Pane[
              Annotation[
               RawBoxes["5"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{2, 1}, 
                "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["6"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{2, 2}, 
                "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["7"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{2, 3}, 
                "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["8"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{2, 4}, 
                "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}]}, {
            Item[
             Pane[
              Annotation[
               RawBoxes["2"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{3, 1}, 
                "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["4"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{3, 2}, 
                "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["6"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{3, 3}, 
                "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["2"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{3, 4}, 
                "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}]}, {
            Item[
             Pane[
              Annotation[
               RawBoxes["5"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{4, 1}, 
                "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["8"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{4, 2}, 
                "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["8"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{4, 3}, 
                "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["3"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{4, 4}, 
                "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}]}}, 
          BaseStyle -> {
           ContextMenu -> 
            Dynamic[TypeSystem`NestedGrid`PackagePrivate`$contextMenuTrigger; 
              Which[TypeSystem`NestedGrid`PackagePrivate`$lastOutputID =!= 
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                 TypeSystem`NestedGrid`PackagePrivate`$outputID$$], {}, 
                TypeSystem`NestedGrid`PackagePrivate`$contextMenuTrigger === 
                TypeSystem`NestedGrid`PackagePrivate`$lastContextMenuTrigger, 
                TypeSystem`NestedGrid`PackagePrivate`$lastContextMenu, True, 
                TypeSystem`NestedGrid`PackagePrivate`$lastContextMenuTrigger = 
                 TypeSystem`NestedGrid`PackagePrivate`$contextMenuTrigger; 
                TypeSystem`NestedGrid`PackagePrivate`$lastContextMenu = 
                 Block[{TypeSystem`NestedGrid`PackagePrivate`$globalScrollPos = \
{TypeSystem`NestedGrid`PackagePrivate`$vPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$hPos$$}}, 
                   
                   With[{TypeSystem`NestedGrid`PackagePrivate`lastPath$ = 
                    TypeSystem`NestedGrid`PackagePrivate`$lastPath, 
                    TypeSystem`NestedGrid`PackagePrivate`lastPathType$ = 
                    TypeSystem`NestedGrid`PackagePrivate`$lastPathType, 
                    TypeSystem`NestedGrid`PackagePrivate`isLeafHeader$ = 
                    TypeSystem`NestedGrid`PackagePrivate`$\
lastPathIsLeafHeader, TypeSystem`NestedGrid`PackagePrivate`allHidden$ = 
                    TypeSystem`NestedGrid`PackagePrivate`allHiddenQ[
                    TypeSystem`NestedGrid`PackagePrivate`$lastPath, 
                    TypeSystem`NestedGrid`PackagePrivate`$state$$], 
                    TypeSystem`NestedGrid`PackagePrivate`anyHidden$ = 
                    TypeSystem`NestedGrid`PackagePrivate`anyHiddenQ[
                    TypeSystem`NestedGrid`PackagePrivate`$lastPath, 
                    TypeSystem`NestedGrid`PackagePrivate`$state$$], 
                    TypeSystem`NestedGrid`PackagePrivate`sortDirection$ = 
                    TypeSystem`NestedGrid`PackagePrivate`columnSortDirection[
                    TypeSystem`NestedGrid`PackagePrivate`$lastPath, 
                    TypeSystem`NestedGrid`PackagePrivate`$state$$[
                    "SortPaths"], 
                    TypeSystem`NestedGrid`PackagePrivate`$state$$[
                    "SortDirections"]], 
                    TypeSystem`NestedGrid`PackagePrivate`haveData$ = Not[
                    FailureQ[
                    TypeSystem`NestedGrid`PackagePrivate`datasetInitialData[
                    TypeSystem`NestedGrid`PackagePrivate`$state$$]]], 
                    TypeSystem`NestedGrid`PackagePrivate`isKeyDummy$ = Not[
                    FreeQ[
                    TypeSystem`NestedGrid`PackagePrivate`$lastPath, Keys]]}, 
                    Join[{
                    If[
                    Or[
                    Not[TypeSystem`NestedGrid`PackagePrivate`haveData$], 
                    Not[TypeSystem`NestedGrid`PackagePrivate`anyHidden$], 
                    TypeSystem`NestedGrid`PackagePrivate`isKeyDummy$], 
                    Nothing, 
                    MenuItem[
                    StringJoin["Show ", 
                    Which[
                    TypeSystem`NestedGrid`PackagePrivate`lastPathType$ == 
                    "Item", "", 
                    TypeSystem`NestedGrid`PackagePrivate`allHidden$, 
                    ToString[
                    ReplaceAll[
                    Last[TypeSystem`NestedGrid`PackagePrivate`lastPath$], 
                    Key[
                    Pattern[TypeSystem`NestedGrid`PackagePrivate`x, 
                    Blank[]]] :> TypeSystem`NestedGrid`PackagePrivate`x]], 
                    TypeSystem`NestedGrid`PackagePrivate`lastPathType$ == 
                    "RowHeader", "Row", 
                    TypeSystem`NestedGrid`PackagePrivate`lastPathType$ == 
                    "ColumnHeader", "Column", True, ""]], 
                    KernelExecute[
                    TypeSystem`NestedGrid`PackagePrivate`updateHiddenItems[
                    TypeSystem`NestedGrid`PackagePrivate`$state$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$path$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$vPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$hPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$grid$$, 
                    TypeSystem`NestedGrid`PackagePrivate`localHold[
                    TypeSystem`NestedGrid`PackagePrivate`localHold[
                    TypeSystem`NestedGrid`PackagePrivate`$outputID$$]]][
                    TypeSystem`NestedGrid`PackagePrivate`lastPath$, 
                    "remove"]], MenuEvaluator -> Automatic]], 
                    If[
                    Or[
                    Not[TypeSystem`NestedGrid`PackagePrivate`haveData$], 
                    TypeSystem`NestedGrid`PackagePrivate`pathEmptyQ[
                    TypeSystem`NestedGrid`PackagePrivate`$lastPath, 
                    TypeSystem`NestedGrid`PackagePrivate`$state$$], 
                    TypeSystem`NestedGrid`PackagePrivate`allHidden$, 
                    TypeSystem`NestedGrid`PackagePrivate`isKeyDummy$], 
                    Nothing, 
                    MenuItem[
                    StringJoin["Hide ", 
                    Which[
                    TypeSystem`NestedGrid`PackagePrivate`lastPathType$ == 
                    "Item", "", 
                    TypeSystem`NestedGrid`PackagePrivate`allHidden$, 
                    ToString[
                    ReplaceAll[
                    Last[TypeSystem`NestedGrid`PackagePrivate`lastPath$], 
                    Key[
                    Pattern[TypeSystem`NestedGrid`PackagePrivate`x, 
                    Blank[]]] :> TypeSystem`NestedGrid`PackagePrivate`x]], 
                    TypeSystem`NestedGrid`PackagePrivate`lastPathType$ == 
                    "RowHeader", "Row", 
                    TypeSystem`NestedGrid`PackagePrivate`lastPathType$ == 
                    "ColumnHeader", "Column", True, ""]], 
                    KernelExecute[
                    TypeSystem`NestedGrid`PackagePrivate`updateHiddenItems[
                    TypeSystem`NestedGrid`PackagePrivate`$state$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$path$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$vPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$hPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$grid$$, 
                    TypeSystem`NestedGrid`PackagePrivate`localHold[
                    TypeSystem`NestedGrid`PackagePrivate`localHold[
                    TypeSystem`NestedGrid`PackagePrivate`$outputID$$]]][
                    TypeSystem`NestedGrid`PackagePrivate`lastPath$, "add"]], 
                    MenuEvaluator -> Automatic]], Delimiter}, 
                    If[
                    And[TypeSystem`NestedGrid`PackagePrivate`haveData$, 
                    MatchQ[TypeSystem`NestedGrid`PackagePrivate`lastPathType$, 
                    Alternatives["ColumnHeader", "KeyDummy"]], 
                    TypeSystem`NestedGrid`PackagePrivate`isLeafHeader$, 
                    Not[TypeSystem`NestedGrid`PackagePrivate`allHidden$]], {
                    If[
                    TypeSystem`NestedGrid`PackagePrivate`sortDirection$ =!= 
                    "Ascending", 
                    MenuItem["Sort", 
                    KernelExecute[
                    TypeSystem`NestedGrid`PackagePrivate`updateSort[
                    TypeSystem`NestedGrid`PackagePrivate`$state$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$path$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$vPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$hPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$grid$$, 
                    TypeSystem`NestedGrid`PackagePrivate`localHold[
                    TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][
                    TypeSystem`NestedGrid`PackagePrivate`lastPath$, 
                    "Ascending"]], MenuEvaluator -> Automatic], Nothing], 
                    If[
                    TypeSystem`NestedGrid`PackagePrivate`sortDirection$ =!= 
                    "Descending", 
                    MenuItem["Reverse Sort", 
                    KernelExecute[
                    TypeSystem`NestedGrid`PackagePrivate`updateSort[
                    TypeSystem`NestedGrid`PackagePrivate`$state$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$path$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$vPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$hPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$grid$$, 
                    TypeSystem`NestedGrid`PackagePrivate`localHold[
                    TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][
                    TypeSystem`NestedGrid`PackagePrivate`lastPath$, 
                    "Descending"]], MenuEvaluator -> Automatic], Nothing], 
                    If[
                    TypeSystem`NestedGrid`PackagePrivate`sortDirection$ =!= 
                    None, 
                    MenuItem["Unsort", 
                    KernelExecute[
                    TypeSystem`NestedGrid`PackagePrivate`updateSort[
                    TypeSystem`NestedGrid`PackagePrivate`$state$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$path$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$vPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$hPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$grid$$, 
                    TypeSystem`NestedGrid`PackagePrivate`localHold[
                    TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][
                    TypeSystem`NestedGrid`PackagePrivate`lastPath$, None]], 
                    MenuEvaluator -> Automatic], Nothing], Delimiter}, {}], {
                    MenuItem["Copy Position to Clipboard", 
                    KernelExecute[
                    TypeSystem`NestedGrid`PackagePrivate`toCurrentPosition[
                    TypeSystem`NestedGrid`PackagePrivate`copyClip]], 
                    MenuEvaluator -> Automatic], 
                    MenuItem["Copy Data to Clipboard", 
                    KernelExecute[
                    TypeSystem`NestedGrid`PackagePrivate`toCurrentData[
                    TypeSystem`NestedGrid`PackagePrivate`$state$$, 
                    TypeSystem`NestedGrid`PackagePrivate`copyClip]], 
                    MenuEvaluator -> Automatic], Delimiter, 
                    MenuItem["Paste Position in New Cell", 
                    KernelExecute[
                    TypeSystem`NestedGrid`PackagePrivate`toCurrentPosition[
                    TypeSystem`NestedGrid`PackagePrivate`cellPaste]], 
                    MenuEvaluator -> Automatic], 
                    MenuItem["Paste Data in New Cell", 
                    KernelExecute[
                    TypeSystem`NestedGrid`PackagePrivate`toCurrentData[
                    TypeSystem`NestedGrid`PackagePrivate`$state$$, 
                    TypeSystem`NestedGrid`PackagePrivate`cellPaste]], 
                    MenuEvaluator -> Automatic]}]]]]], FontFamily -> 
            "Verdana", FontSize -> 12}, Spacings -> {0, 0}, Alignment -> Left,
           Dividers -> All, FrameStyle -> GrayLevel[0.7490196078431373], 
          BaseStyle -> {FontFamily -> "Verdana", FontSize -> 12}], 
         LineBreakWithin -> False, ContextMenu -> {}, NumberMarks -> False, 
         ShowAutoStyles -> False]], 
      TypeSystem`NestedGrid`PackagePrivate`initialQ = True}, 
     Dynamic[
      TypeSystem`NestedGrid`PackagePrivate`setupViewPath[
      TypeSystem`NestedGrid`PackagePrivate`$path$$, If[
         Not[TypeSystem`NestedGrid`PackagePrivate`initialQ], 
         Module[{
          TypeSystem`NestedGrid`PackagePrivate`tmpGrid$ = $Failed, 
           TypeSystem`NestedGrid`PackagePrivate`tmpData$ = 
           TypeSystem`NestedGrid`PackagePrivate`datasetData[
            TypeSystem`NestedGrid`PackagePrivate`$state$$]}, 
          TypeSystem`NestedGrid`PackagePrivate`tmpGrid$ = If[
             FailureQ[TypeSystem`NestedGrid`PackagePrivate`tmpData$], 
             TypeSystem`NestedGrid`PackagePrivate`renderedGrid, 
             TypeSystem`NestedGrid`PackagePrivate`renderGrid[
             TypeSystem`NestedGrid`PackagePrivate`$state$$, 
              TypeSystem`NestedGrid`PackagePrivate`$path$$, 
              TypeSystem`NestedGrid`PackagePrivate`$vPos$$, 
              TypeSystem`NestedGrid`PackagePrivate`$hPos$$, 
              TypeSystem`NestedGrid`PackagePrivate`$grid$$, 
              TypeSystem`NestedGrid`PackagePrivate`localHold[
              TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][
             TypeSystem`NestedGrid`PackagePrivate`tmpData$]]; If[
            Not[
             FailureQ[TypeSystem`NestedGrid`PackagePrivate`tmpGrid$]], 
            TypeSystem`NestedGrid`PackagePrivate`renderedGrid = 
            TypeSystem`NestedGrid`PackagePrivate`tmpGrid$]; Null]]; 
       TypeSystem`NestedGrid`PackagePrivate`initialQ = False; 
       TypeSystem`NestedGrid`PackagePrivate`$vPos$$; 
       TypeSystem`NestedGrid`PackagePrivate`$hPos$$; If[
         FailureQ[TypeSystem`NestedGrid`PackagePrivate`renderedGrid], 
         TypeSystem`SparseGrid[
          TypeSystem`H["(data no longer present)"]], 
         If[GeneralUtilities`$DebugMode, 
          Row[{TypeSystem`NestedGrid`PackagePrivate`renderedGrid, "  ", 
            TypeSystem`NestedGrid`PackagePrivate`formatState[
            TypeSystem`NestedGrid`PackagePrivate`$state$$, 
             TypeSystem`NestedGrid`PackagePrivate`$path$$, 
             TypeSystem`NestedGrid`PackagePrivate`$vPos$$, 
             TypeSystem`NestedGrid`PackagePrivate`$hPos$$]}], 
          TypeSystem`NestedGrid`PackagePrivate`renderedGrid]]], 
      TrackedSymbols :> {
       TypeSystem`NestedGrid`PackagePrivate`$vPos$$, 
        TypeSystem`NestedGrid`PackagePrivate`$hPos$$}], 
     DynamicModuleValues :> {}], 
    TypeSystem`NestedGrid`PackagePrivate`$topBar$$ = Dynamic[
     TypeSystem`NestedGrid`PackagePrivate`makeFramedBar[
      TypeSystem`PackageScope`SubViewPathbar[
      TypeSystem`NestedGrid`PackagePrivate`$path$$, 
       TypeSystem`NestedGrid`PackagePrivate`updateState[
       TypeSystem`NestedGrid`PackagePrivate`$state$$, 
        TypeSystem`NestedGrid`PackagePrivate`$path$$, 
        TypeSystem`NestedGrid`PackagePrivate`$vPos$$, 
        TypeSystem`NestedGrid`PackagePrivate`$hPos$$, 
        TypeSystem`NestedGrid`PackagePrivate`$grid$$, 
        TypeSystem`NestedGrid`PackagePrivate`localHold[
        TypeSystem`NestedGrid`PackagePrivate`$outputID$$]]]], 
     TrackedSymbols :> {TypeSystem`NestedGrid`PackagePrivate`$path$$}], 
    TypeSystem`NestedGrid`PackagePrivate`$bottomBar$$ = Style[
     Framed[
      Dynamic[
       Replace[
       TypeSystem`NestedGrid`PackagePrivate`mouseAnnotation$$, {
        TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
           TypeSystem`NestedGrid`PackagePrivate`localHold[
           TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][Null, 
           Blank[]] -> "", TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
           TypeSystem`NestedGrid`PackagePrivate`localHold[
           TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][
           Pattern[TypeSystem`NestedGrid`PackagePrivate`path$, 
            Blank[]], 
           Pattern[TypeSystem`NestedGrid`PackagePrivate`pathType$, 
            Blank[]], 
           Pattern[TypeSystem`NestedGrid`PackagePrivate`isLeafHeader$, 
            Blank[]]] :> (
          Increment[TypeSystem`NestedGrid`PackagePrivate`$contextMenuTrigger]; 
          TypeSystem`NestedGrid`PackagePrivate`$lastPath = 
           TypeSystem`NestedGrid`PackagePrivate`path$; 
          TypeSystem`NestedGrid`PackagePrivate`$lastPathType = 
           TypeSystem`NestedGrid`PackagePrivate`pathType$; 
          TypeSystem`NestedGrid`PackagePrivate`$lastPathIsLeafHeader = 
           TypeSystem`NestedGrid`PackagePrivate`isLeafHeader$; 
          TypeSystem`NestedGrid`PackagePrivate`$lastOutputID = 
           TypeSystem`NestedGrid`PackagePrivate`localHold[
            TypeSystem`NestedGrid`PackagePrivate`$outputID$$]; 
          TypeSystem`NestedGrid`PackagePrivate`makePathTrail[
           TypeSystem`NestedGrid`PackagePrivate`path$, 
            TypeSystem`NestedGrid`PackagePrivate`makePathElements]), Null :> 
         Spacer[10], Blank[] :> Spacer[10]}], 
       TrackedSymbols :> {
        TypeSystem`NestedGrid`PackagePrivate`mouseAnnotation$$}], FrameStyle -> 
      None, ImageMargins -> 0, FrameMargins -> 0, Alignment -> Top, 
      ImageSize -> {Automatic, 15}], FontSize -> 1], 
    TypeSystem`NestedGrid`PackagePrivate`mouseAnnotation$$ = Null}, 
    DynamicWrapperBox[
     DynamicBox[ToBoxes[
       Dataset`DatasetContent[
       1, "Path" -> TypeSystem`NestedGrid`PackagePrivate`$path$$, "Grid" -> 
        TypeSystem`NestedGrid`PackagePrivate`releaseLocalHold[
         TypeSystem`NestedGrid`PackagePrivate`$grid$$], "State" -> 
        TypeSystem`NestedGrid`PackagePrivate`$state$$, "VPos" -> 
        Hold[TypeSystem`NestedGrid`PackagePrivate`$vPos$$], "HPos" -> 
        Hold[TypeSystem`NestedGrid`PackagePrivate`$hPos$$], "TopBar" -> 
        TypeSystem`NestedGrid`PackagePrivate`$topBar$$, "BottomBar" -> 
        TypeSystem`NestedGrid`PackagePrivate`releaseLocalHold[
         TypeSystem`NestedGrid`PackagePrivate`$bottomBar$$]], StandardForm],
      ImageSizeCache->{189., {65.634033203125, 71.365966796875}},
      TrackedSymbols:>{
       TypeSystem`NestedGrid`PackagePrivate`$state$$, 
        TypeSystem`NestedGrid`PackagePrivate`$grid$$}], 
     TypeSystem`NestedGrid`PackagePrivate`mouseAnnotation$$ = 
     MouseAnnotation[],
     ImageSizeCache->{189., {65.634033203125, 71.365966796875}}],
    BaseStyle->{LineBreakWithin -> False},
    DynamicModuleValues:>{},
    Initialization:>
     Block[{$ContextPath = $ContextPath}, Needs["TypeSystem`"]; 
      Needs["Dataset`"]; 
      TypeSystem`NestedGrid`PackagePrivate`$outputID$$ = CreateUUID[]],
    UnsavedVariables:>{TypeSystem`NestedGrid`PackagePrivate`$outputID$$}],
   Deploy,
   DefaultBaseStyle->"Deploy"],
  Dataset`InterpretDataset[1],
  Editable->False,
  SelectWithContents->True,
  Selectable->False]], "Output",
 CellChangeTimes->{3.798386131002605*^9, 3.79838641415753*^9, 
  3.798987965440805*^9},
 CellLabel->"Out[207]="]
}, Open  ]],

Cell[BoxData[
 DynamicModuleBox[{MOOCNotebook`Quiz`Private`ans$$ = 0}, 
  InterpretationBox[
   StyleBox[GridBox[{
      {GridBox[{
         {
          
          RadioButtonBox[Dynamic[
           MOOCNotebook`Quiz`Private`ans$$, (
            MOOCNotebook`Quiz`Private`ans$$ = #; SetOptions[
              EvaluationNotebook[], 
              TaggingRules -> {"Answers" -> Flatten[{ToString[3] -> #, 
                   DeleteCases[
                    CurrentValue[
                    EvaluationNotebook[], {TaggingRules, "Answers"}], 
                    ToString[3] -> Blank[]]}]}])& ], {1},
           BaselinePosition->Baseline,
           DefaultBaseStyle->"RadioButtonBar"], 
          StyleBox[
           TemplateBox[{
             StyleBox["\" \"", "ProblemChoiceText", StripOnInput -> False], 
             StyleBox[
              Cell[
               TextData[{
                 StyleBox["data[All, 3;;4]", "InlineFormula"]}]], 
              "ProblemChoiceText", StripOnInput -> False]},
            "RowDefault"], "RadioButtonBarLabel",
           StripOnInput->False]}
        },
        AutoDelete->False,
        BaselinePosition->{1, 2},
        GridBoxAlignment->{"Columns" -> {{Left}}, "Rows" -> {{Baseline}}},
        GridBoxItemSize->{"Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}},
        GridBoxSpacings->{"Columns" -> {
            Offset[0.27999999999999997`], {
             Offset[0.21]}, 
            Offset[0.27999999999999997`]}, "Rows" -> {
            Offset[0.2], {
             Offset[0.4]}, 
            Offset[0.2]}}]},
      {GridBox[{
         {
          
          RadioButtonBox[Dynamic[
           MOOCNotebook`Quiz`Private`ans$$, (
            MOOCNotebook`Quiz`Private`ans$$ = #; SetOptions[
              EvaluationNotebook[], 
              TaggingRules -> {"Answers" -> Flatten[{ToString[3] -> #, 
                   DeleteCases[
                    CurrentValue[
                    EvaluationNotebook[], {TaggingRules, "Answers"}], 
                    ToString[3] -> Blank[]]}]}])& ], {2},
           BaselinePosition->Baseline,
           DefaultBaseStyle->"RadioButtonBar"], 
          StyleBox[
           TemplateBox[{
             StyleBox["\" \"", "ProblemChoiceText", StripOnInput -> False], 
             StyleBox[
              Cell[
               TextData[{
                 StyleBox["data[[All, 3;;4]]", "InlineFormula"], " "}]], 
              "ProblemChoiceText", StripOnInput -> False]},
            "RowDefault"], "RadioButtonBarLabel",
           StripOnInput->False]}
        },
        AutoDelete->False,
        BaselinePosition->{1, 2},
        GridBoxAlignment->{"Columns" -> {{Left}}, "Rows" -> {{Baseline}}},
        GridBoxItemSize->{"Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}},
        GridBoxSpacings->{"Columns" -> {
            Offset[0.27999999999999997`], {
             Offset[0.21]}, 
            Offset[0.27999999999999997`]}, "Rows" -> {
            Offset[0.2], {
             Offset[0.4]}, 
            Offset[0.2]}}]},
      {GridBox[{
         {
          
          RadioButtonBox[Dynamic[
           MOOCNotebook`Quiz`Private`ans$$, (
            MOOCNotebook`Quiz`Private`ans$$ = #; SetOptions[
              EvaluationNotebook[], 
              TaggingRules -> {"Answers" -> Flatten[{ToString[3] -> #, 
                   DeleteCases[
                    CurrentValue[
                    EvaluationNotebook[], {TaggingRules, "Answers"}], 
                    ToString[3] -> Blank[]]}]}])& ], {3},
           BaselinePosition->Baseline,
           DefaultBaseStyle->"RadioButtonBar"], 
          StyleBox[
           TemplateBox[{
             StyleBox["\" \"", "ProblemChoiceText", StripOnInput -> False], 
             StyleBox[
              Cell[
               TextData[{
                 StyleBox["data[Rows[{3,4}]]", "InlineFormula"]}]], 
              "ProblemChoiceText", StripOnInput -> False]},
            "RowDefault"], "RadioButtonBarLabel",
           StripOnInput->False]}
        },
        AutoDelete->False,
        BaselinePosition->{1, 2},
        GridBoxAlignment->{"Columns" -> {{Left}}, "Rows" -> {{Baseline}}},
        GridBoxItemSize->{"Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}},
        GridBoxSpacings->{"Columns" -> {
            Offset[0.27999999999999997`], {
             Offset[0.21]}, 
            Offset[0.27999999999999997`]}, "Rows" -> {
            Offset[0.2], {
             Offset[0.4]}, 
            Offset[0.2]}}]},
      {GridBox[{
         {
          
          RadioButtonBox[Dynamic[
           MOOCNotebook`Quiz`Private`ans$$, (
            MOOCNotebook`Quiz`Private`ans$$ = #; SetOptions[
              EvaluationNotebook[], 
              TaggingRules -> {"Answers" -> Flatten[{ToString[3] -> #, 
                   DeleteCases[
                    CurrentValue[
                    EvaluationNotebook[], {TaggingRules, "Answers"}], 
                    ToString[3] -> Blank[]]}]}])& ], {4},
           BaselinePosition->Baseline,
           DefaultBaseStyle->"RadioButtonBar"], 
          StyleBox[
           TemplateBox[{
             StyleBox["\" \"", "ProblemChoiceText", StripOnInput -> False], 
             StyleBox[
              Cell[
               TextData[{
                 StyleBox["data[[3;;4]]", "InlineFormula"]}]], 
              "ProblemChoiceText", StripOnInput -> False]},
            "RowDefault"], "RadioButtonBarLabel",
           StripOnInput->False]}
        },
        AutoDelete->False,
        BaselinePosition->{1, 2},
        GridBoxAlignment->{"Columns" -> {{Left}}, "Rows" -> {{Baseline}}},
        GridBoxItemSize->{"Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}},
        GridBoxSpacings->{"Columns" -> {
            Offset[0.27999999999999997`], {
             Offset[0.21]}, 
            Offset[0.27999999999999997`]}, "Rows" -> {
            Offset[0.2], {
             Offset[0.4]}, 
            Offset[0.2]}}]}
     },
     GridBoxAlignment->{"Columns" -> {{Left}}, "Rows" -> {{Baseline}}}], 
    "Deploy"],
   RadioButtonBar[
    Dynamic[
    MOOCNotebook`Quiz`Private`ans$$, (MOOCNotebook`Quiz`Private`ans$$ = #; 
     SetOptions[
       EvaluationNotebook[], 
       TaggingRules -> {"Answers" -> Flatten[{ToString[3] -> #, 
            DeleteCases[
             CurrentValue[
              EvaluationNotebook[], {TaggingRules, "Answers"}], ToString[3] -> 
             Blank[]]}]}])& ], {1 -> Row[{
        Style[" ", "ProblemChoiceText"], 
        Style[
         RawBoxes[
          Cell[
           TextData[{
             StyleBox["data[All, 3;;4]", "InlineFormula"]}]]], 
         "ProblemChoiceText"]}], 2 -> Row[{
        Style[" ", "ProblemChoiceText"], 
        Style[
         RawBoxes[
          Cell[
           TextData[{
             StyleBox["data[[All, 3;;4]]", "InlineFormula"], " "}]]], 
         "ProblemChoiceText"]}], 3 -> Row[{
        Style[" ", "ProblemChoiceText"], 
        Style[
         RawBoxes[
          Cell[
           TextData[{
             StyleBox["data[Rows[{3,4}]]", "InlineFormula"]}]]], 
         "ProblemChoiceText"]}], 4 -> Row[{
        Style[" ", "ProblemChoiceText"], 
        Style[
         RawBoxes[
          Cell[
           TextData[{
             StyleBox["data[[3;;4]]", "InlineFormula"]}]]], 
         "ProblemChoiceText"]}]}, Appearance -> "Vertical", BaselinePosition -> 
    Baseline]],
  DynamicModuleValues:>{}]], "ProblemChoiceGrid"],

Cell["Problem 4", "ProblemSectionNoFeedback",
 TaggingRules->{"QuestionNum" -> "4"}],

Cell[TextData[{
 "Given the dataset in this value of ",
 StyleBox["data", "InlineFormula"],
 ", which of these inputs will give a list of the entries larger than 6 in \
column c3?"
}], "ProblemCaption"],

Cell[CellGroupData[{

Cell[BoxData[
 RowBox[{"data", "=", 
  RowBox[{"Dataset", "[", 
   RowBox[{"{", 
    RowBox[{
     RowBox[{"<|", 
      RowBox[{
       RowBox[{"\"\<c1\>\"", "->", "1"}], ",", 
       RowBox[{"\"\<c2\>\"", "->", "1"}], ",", 
       RowBox[{"\"\<c3\>\"", "->", "3"}], ",", 
       RowBox[{"\"\<c4\>\"", "->", "0"}]}], "|>"}], ",", 
     RowBox[{"<|", 
      RowBox[{
       RowBox[{"\"\<c1\>\"", "->", "5"}], ",", 
       RowBox[{"\"\<c2\>\"", "->", "6"}], ",", 
       RowBox[{"\"\<c3\>\"", "->", "7"}], ",", 
       RowBox[{"\"\<c4\>\"", "->", "8"}]}], "|>"}], ",", 
     RowBox[{"<|", 
      RowBox[{
       RowBox[{"\"\<c1\>\"", "->", "2"}], ",", 
       RowBox[{"\"\<c2\>\"", "->", "4"}], ",", 
       RowBox[{"\"\<c3\>\"", "->", "5"}], ",", 
       RowBox[{"\"\<c4\>\"", "->", "2"}]}], "|>"}], ",", 
     RowBox[{"<|", 
      RowBox[{
       RowBox[{"\"\<c1\>\"", "->", "5"}], ",", 
       RowBox[{"\"\<c2\>\"", "->", "8"}], ",", 
       RowBox[{"\"\<c3\>\"", "->", "8"}], ",", 
       RowBox[{"\"\<c4\>\"", "->", "3"}]}], "|>"}]}], "}"}], "]"}]}]], "Input",\

 CellChangeTimes->{{3.798386126161674*^9, 3.7983861306918573`*^9}, 
   3.798386586540514*^9, 3.798386699058778*^9, {3.7983867418273687`*^9, 
   3.798386856344851*^9}},
 CellLabel->"In[209]:="],

Cell[BoxData[
 TagBox[
  TagBox[
   DynamicModuleBox[{TypeSystem`NestedGrid`PackagePrivate`$state$$ = 
    Association["InitialData" -> {
       Association["c1" -> 1, "c2" -> 1, "c3" -> 3, "c4" -> 0], 
       Association["c1" -> 5, "c2" -> 6, "c3" -> 7, "c4" -> 8], 
       Association["c1" -> 2, "c2" -> 4, "c3" -> 5, "c4" -> 2], 
       Association["c1" -> 5, "c2" -> 8, "c3" -> 8, "c4" -> 3]}, 
     "InitialShape" -> TypeSystem`PackageScope`HeaderShape[
       Association[{All, "c1"} -> 1, {All, "c2"} -> 1, {All, "c3"} -> 
        1, {All, "c4"} -> 1], 
       TypeSystem`PackageScope`Limited[
        TypeSystem`PackageScope`ColumnShape[
         TypeSystem`PackageScope`Limited[
          TypeSystem`PackageScope`RowShape[
           Association[
           "c1" -> TypeSystem`PackageScope`AtomShape[34], "c2" -> 
            TypeSystem`PackageScope`AtomShape[34], "c3" -> 
            TypeSystem`PackageScope`AtomShape[34], "c4" -> 
            TypeSystem`PackageScope`AtomShape[34]]], 
          DirectedInfinity[1], 4, {All}]], 4, 
        DirectedInfinity[1], {}]], "InitialType" -> TypeSystem`Vector[
       TypeSystem`Struct[{"c1", "c2", "c3", "c4"}, {
         TypeSystem`Atom[Integer], 
         TypeSystem`Atom[Integer], 
         TypeSystem`Atom[Integer], 
         TypeSystem`Atom[Integer]}], 4], "Meta" -> 
     Association["ID" -> 73233688810925], "RowTarget" -> 20, "ColumnTarget" -> 
     10, "Shape" -> TypeSystem`PackageScope`HeaderShape[
       Association[{All, "c1"} -> 1, {All, "c2"} -> 1, {All, "c3"} -> 
        1, {All, "c4"} -> 1], 
       TypeSystem`PackageScope`Limited[
        TypeSystem`PackageScope`ColumnShape[
         TypeSystem`PackageScope`Limited[
          TypeSystem`PackageScope`RowShape[
           Association[
           "c1" -> TypeSystem`PackageScope`AtomShape[34], "c2" -> 
            TypeSystem`PackageScope`AtomShape[34], "c3" -> 
            TypeSystem`PackageScope`AtomShape[34], "c4" -> 
            TypeSystem`PackageScope`AtomShape[34]]], 
          DirectedInfinity[1], 4, {All}]], 4, 
        DirectedInfinity[1], {}]], "Type" -> TypeSystem`Vector[
       TypeSystem`Struct[{"c1", "c2", "c3", "c4"}, {
         TypeSystem`Atom[Integer], 
         TypeSystem`Atom[Integer], 
         TypeSystem`Atom[Integer], 
         TypeSystem`Atom[Integer]}], 4], "Path" -> {}, "BaseIndices" -> {}, 
     "DisplayedRowCount" -> 4, "DisplayedColumnCount" -> 4, "DataRowCount" -> 
     4, "DataColumnCount" -> 4, "SortPaths" -> {}, "SortDirections" -> {}, 
     "HiddenItemsMap" -> Null, "UpdateType" -> 1], 
    TypeSystem`NestedGrid`PackagePrivate`$outputID$$, 
    TypeSystem`NestedGrid`PackagePrivate`$path$$ = {}, 
    TypeSystem`NestedGrid`PackagePrivate`$vPos$$ = 1, 
    TypeSystem`NestedGrid`PackagePrivate`$hPos$$ = 1, 
    TypeSystem`NestedGrid`PackagePrivate`$grid$$ = 
    DynamicModule[{
     TypeSystem`NestedGrid`PackagePrivate`renderedGrid = Deploy[
        Style[
         Grid[{{
            Item[
             Pane[
              Row[{
                Annotation[
                 EventHandler[
                  MouseAppearance[
                   Mouseover["c1", 
                    Style[
                    "c1", FontColor -> 
                    RGBColor[
                    0.27450980392156865`, 0.5372549019607843, 
                    0.792156862745098]]], "LinkHand"], {"MouseClicked", 1} :> 
                  TypeSystem`NestedGrid`PackagePrivate`updateState[
                   TypeSystem`NestedGrid`PackagePrivate`$state$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$path$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$vPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$hPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$grid$$, 
                    TypeSystem`NestedGrid`PackagePrivate`localHold[
                    TypeSystem`NestedGrid`PackagePrivate`localHold[
                    TypeSystem`NestedGrid`PackagePrivate`$outputID$$]]][{
                    All, "c1"}, 1]], 
                 TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                  TypeSystem`NestedGrid`PackagePrivate`localHold[
                  TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{
                  All, "c1"}, "ColumnHeader", True], "Mouse"], " ", ""}], 
              ImageSize -> {{1, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], Background -> 
             GrayLevel[0.95], Alignment -> {Left, Baseline}], 
            Item[
             Pane[
              Row[{
                Annotation[
                 EventHandler[
                  MouseAppearance[
                   Mouseover["c2", 
                    Style[
                    "c2", FontColor -> 
                    RGBColor[
                    0.27450980392156865`, 0.5372549019607843, 
                    0.792156862745098]]], "LinkHand"], {"MouseClicked", 1} :> 
                  TypeSystem`NestedGrid`PackagePrivate`updateState[
                   TypeSystem`NestedGrid`PackagePrivate`$state$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$path$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$vPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$hPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$grid$$, 
                    TypeSystem`NestedGrid`PackagePrivate`localHold[
                    TypeSystem`NestedGrid`PackagePrivate`localHold[
                    TypeSystem`NestedGrid`PackagePrivate`$outputID$$]]][{
                    All, "c2"}, 1]], 
                 TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                  TypeSystem`NestedGrid`PackagePrivate`localHold[
                  TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{
                  All, "c2"}, "ColumnHeader", True], "Mouse"], " ", ""}], 
              ImageSize -> {{1, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], Background -> 
             GrayLevel[0.95], Alignment -> {Left, Baseline}], 
            Item[
             Pane[
              Row[{
                Annotation[
                 EventHandler[
                  MouseAppearance[
                   Mouseover["c3", 
                    Style[
                    "c3", FontColor -> 
                    RGBColor[
                    0.27450980392156865`, 0.5372549019607843, 
                    0.792156862745098]]], "LinkHand"], {"MouseClicked", 1} :> 
                  TypeSystem`NestedGrid`PackagePrivate`updateState[
                   TypeSystem`NestedGrid`PackagePrivate`$state$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$path$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$vPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$hPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$grid$$, 
                    TypeSystem`NestedGrid`PackagePrivate`localHold[
                    TypeSystem`NestedGrid`PackagePrivate`localHold[
                    TypeSystem`NestedGrid`PackagePrivate`$outputID$$]]][{
                    All, "c3"}, 1]], 
                 TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                  TypeSystem`NestedGrid`PackagePrivate`localHold[
                  TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{
                  All, "c3"}, "ColumnHeader", True], "Mouse"], " ", ""}], 
              ImageSize -> {{1, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], Background -> 
             GrayLevel[0.95], Alignment -> {Left, Baseline}], 
            Item[
             Pane[
              Row[{
                Annotation[
                 EventHandler[
                  MouseAppearance[
                   Mouseover["c4", 
                    Style[
                    "c4", FontColor -> 
                    RGBColor[
                    0.27450980392156865`, 0.5372549019607843, 
                    0.792156862745098]]], "LinkHand"], {"MouseClicked", 1} :> 
                  TypeSystem`NestedGrid`PackagePrivate`updateState[
                   TypeSystem`NestedGrid`PackagePrivate`$state$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$path$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$vPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$hPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$grid$$, 
                    TypeSystem`NestedGrid`PackagePrivate`localHold[
                    TypeSystem`NestedGrid`PackagePrivate`localHold[
                    TypeSystem`NestedGrid`PackagePrivate`$outputID$$]]][{
                    All, "c4"}, 1]], 
                 TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                  TypeSystem`NestedGrid`PackagePrivate`localHold[
                  TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{
                  All, "c4"}, "ColumnHeader", True], "Mouse"], " ", ""}], 
              ImageSize -> {{1, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], Background -> 
             GrayLevel[0.95], Alignment -> {Left, Baseline}]}, {
            Item[
             Pane[
              Annotation[
               RawBoxes["1"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{1, 
                 Key["c1"]}, "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["1"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{1, 
                 Key["c2"]}, "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["3"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{1, 
                 Key["c3"]}, "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["0"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{1, 
                 Key["c4"]}, "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}]}, {
            Item[
             Pane[
              Annotation[
               RawBoxes["5"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{2, 
                 Key["c1"]}, "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["6"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{2, 
                 Key["c2"]}, "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["7"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{2, 
                 Key["c3"]}, "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["8"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{2, 
                 Key["c4"]}, "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}]}, {
            Item[
             Pane[
              Annotation[
               RawBoxes["2"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{3, 
                 Key["c1"]}, "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["4"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{3, 
                 Key["c2"]}, "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["5"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{3, 
                 Key["c3"]}, "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["2"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{3, 
                 Key["c4"]}, "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}]}, {
            Item[
             Pane[
              Annotation[
               RawBoxes["5"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{4, 
                 Key["c1"]}, "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["8"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{4, 
                 Key["c2"]}, "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["8"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{4, 
                 Key["c3"]}, "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["3"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{4, 
                 Key["c4"]}, "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}]}}, 
          BaseStyle -> {
           ContextMenu -> 
            Dynamic[TypeSystem`NestedGrid`PackagePrivate`$contextMenuTrigger; 
              Which[TypeSystem`NestedGrid`PackagePrivate`$lastOutputID =!= 
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                 TypeSystem`NestedGrid`PackagePrivate`$outputID$$], {}, 
                TypeSystem`NestedGrid`PackagePrivate`$contextMenuTrigger === 
                TypeSystem`NestedGrid`PackagePrivate`$lastContextMenuTrigger, 
                TypeSystem`NestedGrid`PackagePrivate`$lastContextMenu, True, 
                TypeSystem`NestedGrid`PackagePrivate`$lastContextMenuTrigger = 
                 TypeSystem`NestedGrid`PackagePrivate`$contextMenuTrigger; 
                TypeSystem`NestedGrid`PackagePrivate`$lastContextMenu = 
                 Block[{TypeSystem`NestedGrid`PackagePrivate`$globalScrollPos = \
{TypeSystem`NestedGrid`PackagePrivate`$vPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$hPos$$}}, 
                   
                   With[{TypeSystem`NestedGrid`PackagePrivate`lastPath$ = 
                    TypeSystem`NestedGrid`PackagePrivate`$lastPath, 
                    TypeSystem`NestedGrid`PackagePrivate`lastPathType$ = 
                    TypeSystem`NestedGrid`PackagePrivate`$lastPathType, 
                    TypeSystem`NestedGrid`PackagePrivate`isLeafHeader$ = 
                    TypeSystem`NestedGrid`PackagePrivate`$\
lastPathIsLeafHeader, TypeSystem`NestedGrid`PackagePrivate`allHidden$ = 
                    TypeSystem`NestedGrid`PackagePrivate`allHiddenQ[
                    TypeSystem`NestedGrid`PackagePrivate`$lastPath, 
                    TypeSystem`NestedGrid`PackagePrivate`$state$$], 
                    TypeSystem`NestedGrid`PackagePrivate`anyHidden$ = 
                    TypeSystem`NestedGrid`PackagePrivate`anyHiddenQ[
                    TypeSystem`NestedGrid`PackagePrivate`$lastPath, 
                    TypeSystem`NestedGrid`PackagePrivate`$state$$], 
                    TypeSystem`NestedGrid`PackagePrivate`sortDirection$ = 
                    TypeSystem`NestedGrid`PackagePrivate`columnSortDirection[
                    TypeSystem`NestedGrid`PackagePrivate`$lastPath, 
                    TypeSystem`NestedGrid`PackagePrivate`$state$$[
                    "SortPaths"], 
                    TypeSystem`NestedGrid`PackagePrivate`$state$$[
                    "SortDirections"]], 
                    TypeSystem`NestedGrid`PackagePrivate`haveData$ = Not[
                    FailureQ[
                    TypeSystem`NestedGrid`PackagePrivate`datasetInitialData[
                    TypeSystem`NestedGrid`PackagePrivate`$state$$]]], 
                    TypeSystem`NestedGrid`PackagePrivate`isKeyDummy$ = Not[
                    FreeQ[
                    TypeSystem`NestedGrid`PackagePrivate`$lastPath, Keys]]}, 
                    Join[{
                    If[
                    Or[
                    Not[TypeSystem`NestedGrid`PackagePrivate`haveData$], 
                    Not[TypeSystem`NestedGrid`PackagePrivate`anyHidden$], 
                    TypeSystem`NestedGrid`PackagePrivate`isKeyDummy$], 
                    Nothing, 
                    MenuItem[
                    StringJoin["Show ", 
                    Which[
                    TypeSystem`NestedGrid`PackagePrivate`lastPathType$ == 
                    "Item", "", 
                    TypeSystem`NestedGrid`PackagePrivate`allHidden$, 
                    ToString[
                    ReplaceAll[
                    Last[TypeSystem`NestedGrid`PackagePrivate`lastPath$], 
                    Key[
                    Pattern[TypeSystem`NestedGrid`PackagePrivate`x, 
                    Blank[]]] :> TypeSystem`NestedGrid`PackagePrivate`x]], 
                    TypeSystem`NestedGrid`PackagePrivate`lastPathType$ == 
                    "RowHeader", "Row", 
                    TypeSystem`NestedGrid`PackagePrivate`lastPathType$ == 
                    "ColumnHeader", "Column", True, ""]], 
                    KernelExecute[
                    TypeSystem`NestedGrid`PackagePrivate`updateHiddenItems[
                    TypeSystem`NestedGrid`PackagePrivate`$state$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$path$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$vPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$hPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$grid$$, 
                    TypeSystem`NestedGrid`PackagePrivate`localHold[
                    TypeSystem`NestedGrid`PackagePrivate`localHold[
                    TypeSystem`NestedGrid`PackagePrivate`$outputID$$]]][
                    TypeSystem`NestedGrid`PackagePrivate`lastPath$, 
                    "remove"]], MenuEvaluator -> Automatic]], 
                    If[
                    Or[
                    Not[TypeSystem`NestedGrid`PackagePrivate`haveData$], 
                    TypeSystem`NestedGrid`PackagePrivate`pathEmptyQ[
                    TypeSystem`NestedGrid`PackagePrivate`$lastPath, 
                    TypeSystem`NestedGrid`PackagePrivate`$state$$], 
                    TypeSystem`NestedGrid`PackagePrivate`allHidden$, 
                    TypeSystem`NestedGrid`PackagePrivate`isKeyDummy$], 
                    Nothing, 
                    MenuItem[
                    StringJoin["Hide ", 
                    Which[TypeSystem`NestedGrid`PackagePrivate`lastPathType$ == 
                    "Item", "", 
                    TypeSystem`NestedGrid`PackagePrivate`allHidden$, 
                    ToString[
                    ReplaceAll[
                    Last[TypeSystem`NestedGrid`PackagePrivate`lastPath$], 
                    Key[
                    Pattern[TypeSystem`NestedGrid`PackagePrivate`x, 
                    Blank[]]] :> TypeSystem`NestedGrid`PackagePrivate`x]], 
                    TypeSystem`NestedGrid`PackagePrivate`lastPathType$ == 
                    "RowHeader", "Row", 
                    TypeSystem`NestedGrid`PackagePrivate`lastPathType$ == 
                    "ColumnHeader", "Column", True, ""]], 
                    KernelExecute[
                    TypeSystem`NestedGrid`PackagePrivate`updateHiddenItems[
                    TypeSystem`NestedGrid`PackagePrivate`$state$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$path$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$vPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$hPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$grid$$, 
                    TypeSystem`NestedGrid`PackagePrivate`localHold[
                    TypeSystem`NestedGrid`PackagePrivate`localHold[
                    TypeSystem`NestedGrid`PackagePrivate`$outputID$$]]][
                    TypeSystem`NestedGrid`PackagePrivate`lastPath$, "add"]], 
                    MenuEvaluator -> Automatic]], Delimiter}, 
                    If[
                    And[TypeSystem`NestedGrid`PackagePrivate`haveData$, 
                    MatchQ[TypeSystem`NestedGrid`PackagePrivate`lastPathType$, 
                    Alternatives["ColumnHeader", "KeyDummy"]], 
                    TypeSystem`NestedGrid`PackagePrivate`isLeafHeader$, 
                    Not[TypeSystem`NestedGrid`PackagePrivate`allHidden$]], {
                    If[
                    TypeSystem`NestedGrid`PackagePrivate`sortDirection$ =!= 
                    "Ascending", 
                    MenuItem["Sort", 
                    KernelExecute[
                    TypeSystem`NestedGrid`PackagePrivate`updateSort[
                    TypeSystem`NestedGrid`PackagePrivate`$state$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$path$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$vPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$hPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$grid$$, 
                    TypeSystem`NestedGrid`PackagePrivate`localHold[
                    TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][
                    TypeSystem`NestedGrid`PackagePrivate`lastPath$, 
                    "Ascending"]], MenuEvaluator -> Automatic], Nothing], 
                    If[
                    TypeSystem`NestedGrid`PackagePrivate`sortDirection$ =!= 
                    "Descending", 
                    MenuItem["Reverse Sort", 
                    KernelExecute[
                    TypeSystem`NestedGrid`PackagePrivate`updateSort[
                    TypeSystem`NestedGrid`PackagePrivate`$state$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$path$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$vPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$hPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$grid$$, 
                    TypeSystem`NestedGrid`PackagePrivate`localHold[
                    TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][
                    TypeSystem`NestedGrid`PackagePrivate`lastPath$, 
                    "Descending"]], MenuEvaluator -> Automatic], Nothing], 
                    If[
                    TypeSystem`NestedGrid`PackagePrivate`sortDirection$ =!= 
                    None, 
                    MenuItem["Unsort", 
                    KernelExecute[
                    TypeSystem`NestedGrid`PackagePrivate`updateSort[
                    TypeSystem`NestedGrid`PackagePrivate`$state$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$path$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$vPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$hPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$grid$$, 
                    TypeSystem`NestedGrid`PackagePrivate`localHold[
                    TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][
                    TypeSystem`NestedGrid`PackagePrivate`lastPath$, None]], 
                    MenuEvaluator -> Automatic], Nothing], Delimiter}, {}], {
                    MenuItem["Copy Position to Clipboard", 
                    KernelExecute[
                    TypeSystem`NestedGrid`PackagePrivate`toCurrentPosition[
                    TypeSystem`NestedGrid`PackagePrivate`copyClip]], 
                    MenuEvaluator -> Automatic], 
                    MenuItem["Copy Data to Clipboard", 
                    KernelExecute[
                    TypeSystem`NestedGrid`PackagePrivate`toCurrentData[
                    TypeSystem`NestedGrid`PackagePrivate`$state$$, 
                    TypeSystem`NestedGrid`PackagePrivate`copyClip]], 
                    MenuEvaluator -> Automatic], Delimiter, 
                    MenuItem["Paste Position in New Cell", 
                    KernelExecute[
                    TypeSystem`NestedGrid`PackagePrivate`toCurrentPosition[
                    TypeSystem`NestedGrid`PackagePrivate`cellPaste]], 
                    MenuEvaluator -> Automatic], 
                    MenuItem["Paste Data in New Cell", 
                    KernelExecute[
                    TypeSystem`NestedGrid`PackagePrivate`toCurrentData[
                    TypeSystem`NestedGrid`PackagePrivate`$state$$, 
                    TypeSystem`NestedGrid`PackagePrivate`cellPaste]], 
                    MenuEvaluator -> Automatic]}]]]]], FontFamily -> 
            "Verdana", FontSize -> 12}, Spacings -> {0, 0}, Alignment -> Left,
           Dividers -> All, FrameStyle -> GrayLevel[0.7490196078431373], 
          BaseStyle -> {FontFamily -> "Verdana", FontSize -> 12}], 
         LineBreakWithin -> False, ContextMenu -> {}, NumberMarks -> False, 
         ShowAutoStyles -> False]], 
      TypeSystem`NestedGrid`PackagePrivate`initialQ = True}, 
     Dynamic[
      TypeSystem`NestedGrid`PackagePrivate`setupViewPath[
      TypeSystem`NestedGrid`PackagePrivate`$path$$, If[
         Not[TypeSystem`NestedGrid`PackagePrivate`initialQ], 
         Module[{
          TypeSystem`NestedGrid`PackagePrivate`tmpGrid$ = $Failed, 
           TypeSystem`NestedGrid`PackagePrivate`tmpData$ = 
           TypeSystem`NestedGrid`PackagePrivate`datasetData[
            TypeSystem`NestedGrid`PackagePrivate`$state$$]}, 
          TypeSystem`NestedGrid`PackagePrivate`tmpGrid$ = If[
             FailureQ[TypeSystem`NestedGrid`PackagePrivate`tmpData$], 
             TypeSystem`NestedGrid`PackagePrivate`renderedGrid, 
             TypeSystem`NestedGrid`PackagePrivate`renderGrid[
             TypeSystem`NestedGrid`PackagePrivate`$state$$, 
              TypeSystem`NestedGrid`PackagePrivate`$path$$, 
              TypeSystem`NestedGrid`PackagePrivate`$vPos$$, 
              TypeSystem`NestedGrid`PackagePrivate`$hPos$$, 
              TypeSystem`NestedGrid`PackagePrivate`$grid$$, 
              TypeSystem`NestedGrid`PackagePrivate`localHold[
              TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][
             TypeSystem`NestedGrid`PackagePrivate`tmpData$]]; If[
            Not[
             FailureQ[TypeSystem`NestedGrid`PackagePrivate`tmpGrid$]], 
            TypeSystem`NestedGrid`PackagePrivate`renderedGrid = 
            TypeSystem`NestedGrid`PackagePrivate`tmpGrid$]; Null]]; 
       TypeSystem`NestedGrid`PackagePrivate`initialQ = False; 
       TypeSystem`NestedGrid`PackagePrivate`$vPos$$; 
       TypeSystem`NestedGrid`PackagePrivate`$hPos$$; If[
         FailureQ[TypeSystem`NestedGrid`PackagePrivate`renderedGrid], 
         TypeSystem`SparseGrid[
          TypeSystem`H["(data no longer present)"]], 
         If[GeneralUtilities`$DebugMode, 
          Row[{TypeSystem`NestedGrid`PackagePrivate`renderedGrid, "  ", 
            TypeSystem`NestedGrid`PackagePrivate`formatState[
            TypeSystem`NestedGrid`PackagePrivate`$state$$, 
             TypeSystem`NestedGrid`PackagePrivate`$path$$, 
             TypeSystem`NestedGrid`PackagePrivate`$vPos$$, 
             TypeSystem`NestedGrid`PackagePrivate`$hPos$$]}], 
          TypeSystem`NestedGrid`PackagePrivate`renderedGrid]]], 
      TrackedSymbols :> {
       TypeSystem`NestedGrid`PackagePrivate`$vPos$$, 
        TypeSystem`NestedGrid`PackagePrivate`$hPos$$}], 
     DynamicModuleValues :> {}], 
    TypeSystem`NestedGrid`PackagePrivate`$topBar$$ = Dynamic[
     TypeSystem`NestedGrid`PackagePrivate`makeFramedBar[
      TypeSystem`PackageScope`SubViewPathbar[
      TypeSystem`NestedGrid`PackagePrivate`$path$$, 
       TypeSystem`NestedGrid`PackagePrivate`updateState[
       TypeSystem`NestedGrid`PackagePrivate`$state$$, 
        TypeSystem`NestedGrid`PackagePrivate`$path$$, 
        TypeSystem`NestedGrid`PackagePrivate`$vPos$$, 
        TypeSystem`NestedGrid`PackagePrivate`$hPos$$, 
        TypeSystem`NestedGrid`PackagePrivate`$grid$$, 
        TypeSystem`NestedGrid`PackagePrivate`localHold[
        TypeSystem`NestedGrid`PackagePrivate`$outputID$$]]]], 
     TrackedSymbols :> {TypeSystem`NestedGrid`PackagePrivate`$path$$}], 
    TypeSystem`NestedGrid`PackagePrivate`$bottomBar$$ = Style[
     Framed[
      Dynamic[
       Replace[
       TypeSystem`NestedGrid`PackagePrivate`mouseAnnotation$$, {
        TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
           TypeSystem`NestedGrid`PackagePrivate`localHold[
           TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][Null, 
           Blank[]] -> "", TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
           TypeSystem`NestedGrid`PackagePrivate`localHold[
           TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][
           Pattern[TypeSystem`NestedGrid`PackagePrivate`path$, 
            Blank[]], 
           Pattern[TypeSystem`NestedGrid`PackagePrivate`pathType$, 
            Blank[]], 
           Pattern[TypeSystem`NestedGrid`PackagePrivate`isLeafHeader$, 
            Blank[]]] :> (
          Increment[TypeSystem`NestedGrid`PackagePrivate`$contextMenuTrigger]; 
          TypeSystem`NestedGrid`PackagePrivate`$lastPath = 
           TypeSystem`NestedGrid`PackagePrivate`path$; 
          TypeSystem`NestedGrid`PackagePrivate`$lastPathType = 
           TypeSystem`NestedGrid`PackagePrivate`pathType$; 
          TypeSystem`NestedGrid`PackagePrivate`$lastPathIsLeafHeader = 
           TypeSystem`NestedGrid`PackagePrivate`isLeafHeader$; 
          TypeSystem`NestedGrid`PackagePrivate`$lastOutputID = 
           TypeSystem`NestedGrid`PackagePrivate`localHold[
            TypeSystem`NestedGrid`PackagePrivate`$outputID$$]; 
          TypeSystem`NestedGrid`PackagePrivate`makePathTrail[
           TypeSystem`NestedGrid`PackagePrivate`path$, 
            TypeSystem`NestedGrid`PackagePrivate`makePathElements]), Null :> 
         Spacer[10], Blank[] :> Spacer[10]}], 
       TrackedSymbols :> {
        TypeSystem`NestedGrid`PackagePrivate`mouseAnnotation$$}], FrameStyle -> 
      None, ImageMargins -> 0, FrameMargins -> 0, Alignment -> Top, 
      ImageSize -> {Automatic, 15}], FontSize -> 1], 
    TypeSystem`NestedGrid`PackagePrivate`mouseAnnotation$$ = Null}, 
    DynamicWrapperBox[
     DynamicBox[ToBoxes[
       Dataset`DatasetContent[
       1, "Path" -> TypeSystem`NestedGrid`PackagePrivate`$path$$, "Grid" -> 
        TypeSystem`NestedGrid`PackagePrivate`releaseLocalHold[
         TypeSystem`NestedGrid`PackagePrivate`$grid$$], "State" -> 
        TypeSystem`NestedGrid`PackagePrivate`$state$$, "VPos" -> 
        Hold[TypeSystem`NestedGrid`PackagePrivate`$vPos$$], "HPos" -> 
        Hold[TypeSystem`NestedGrid`PackagePrivate`$hPos$$], "TopBar" -> 
        TypeSystem`NestedGrid`PackagePrivate`$topBar$$, "BottomBar" -> 
        TypeSystem`NestedGrid`PackagePrivate`releaseLocalHold[
         TypeSystem`NestedGrid`PackagePrivate`$bottomBar$$]], StandardForm],
      ImageSizeCache->{189., {78.134033203125, 83.865966796875}},
      TrackedSymbols:>{
       TypeSystem`NestedGrid`PackagePrivate`$state$$, 
        TypeSystem`NestedGrid`PackagePrivate`$grid$$}], 
     TypeSystem`NestedGrid`PackagePrivate`mouseAnnotation$$ = 
     MouseAnnotation[],
     ImageSizeCache->{189., {78.134033203125, 83.865966796875}}],
    BaseStyle->{LineBreakWithin -> False},
    DynamicModuleValues:>{},
    Initialization:>
     Block[{$ContextPath = $ContextPath}, Needs["TypeSystem`"]; 
      Needs["Dataset`"]; 
      TypeSystem`NestedGrid`PackagePrivate`$outputID$$ = CreateUUID[]],
    UnsavedVariables:>{TypeSystem`NestedGrid`PackagePrivate`$outputID$$}],
   Deploy,
   DefaultBaseStyle->"Deploy"],
  Dataset`InterpretDataset[1],
  Editable->False,
  SelectWithContents->True,
  Selectable->False]], "Output",
 CellChangeTimes->{3.798386131002605*^9, 3.79838641415753*^9, 
  3.798386587050527*^9, 3.7983867015174417`*^9, 3.798386812288844*^9, 
  3.798386856761642*^9, 3.79838688957076*^9, 3.798988028603012*^9},
 CellLabel->"Out[209]="]
}, Open  ]],

Cell[BoxData[
 DynamicModuleBox[{MOOCNotebook`Quiz`Private`ans$$ = 0}, 
  InterpretationBox[
   StyleBox[GridBox[{
      {GridBox[{
         {
          
          RadioButtonBox[Dynamic[
           MOOCNotebook`Quiz`Private`ans$$, (
            MOOCNotebook`Quiz`Private`ans$$ = #; SetOptions[
              EvaluationNotebook[], 
              TaggingRules -> {"Answers" -> Flatten[{ToString[4] -> #, 
                   DeleteCases[
                    CurrentValue[
                    EvaluationNotebook[], {TaggingRules, "Answers"}], 
                    ToString[4] -> Blank[]]}]}])& ], {1},
           BaselinePosition->Baseline,
           DefaultBaseStyle->"RadioButtonBar"], 
          StyleBox[
           TemplateBox[{
             StyleBox["\" \"", "ProblemChoiceText", StripOnInput -> False], 
             StyleBox[
              Cell[
               TextData[{
                 StyleBox[
                 "data[Select[#>6&], #c3&]//Normal", "InlineFormula"]}]], 
              "ProblemChoiceText", StripOnInput -> False]},
            "RowDefault"], "RadioButtonBarLabel",
           StripOnInput->False]}
        },
        AutoDelete->False,
        BaselinePosition->{1, 2},
        GridBoxAlignment->{"Columns" -> {{Left}}, "Rows" -> {{Baseline}}},
        GridBoxItemSize->{"Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}},
        GridBoxSpacings->{"Columns" -> {
            Offset[0.27999999999999997`], {
             Offset[0.21]}, 
            Offset[0.27999999999999997`]}, "Rows" -> {
            Offset[0.2], {
             Offset[0.4]}, 
            Offset[0.2]}}]},
      {GridBox[{
         {
          
          RadioButtonBox[Dynamic[
           MOOCNotebook`Quiz`Private`ans$$, (
            MOOCNotebook`Quiz`Private`ans$$ = #; SetOptions[
              EvaluationNotebook[], 
              TaggingRules -> {"Answers" -> Flatten[{ToString[4] -> #, 
                   DeleteCases[
                    CurrentValue[
                    EvaluationNotebook[], {TaggingRules, "Answers"}], 
                    ToString[4] -> Blank[]]}]}])& ], {2},
           BaselinePosition->Baseline,
           DefaultBaseStyle->"RadioButtonBar"], 
          StyleBox[
           TemplateBox[{
             StyleBox["\" \"", "ProblemChoiceText", StripOnInput -> False], 
             StyleBox[
              Cell[
               TextData[{
                 StyleBox[
                 "data[Select[#c3>6&], \"c3\"]//Normal", "InlineFormula"]}]], 
              "ProblemChoiceText", StripOnInput -> False]},
            "RowDefault"], "RadioButtonBarLabel",
           StripOnInput->False]}
        },
        AutoDelete->False,
        BaselinePosition->{1, 2},
        GridBoxAlignment->{"Columns" -> {{Left}}, "Rows" -> {{Baseline}}},
        GridBoxItemSize->{"Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}},
        GridBoxSpacings->{"Columns" -> {
            Offset[0.27999999999999997`], {
             Offset[0.21]}, 
            Offset[0.27999999999999997`]}, "Rows" -> {
            Offset[0.2], {
             Offset[0.4]}, 
            Offset[0.2]}}]},
      {GridBox[{
         {
          
          RadioButtonBox[Dynamic[
           MOOCNotebook`Quiz`Private`ans$$, (
            MOOCNotebook`Quiz`Private`ans$$ = #; SetOptions[
              EvaluationNotebook[], 
              TaggingRules -> {"Answers" -> Flatten[{ToString[4] -> #, 
                   DeleteCases[
                    CurrentValue[
                    EvaluationNotebook[], {TaggingRules, "Answers"}], 
                    ToString[4] -> Blank[]]}]}])& ], {3},
           BaselinePosition->Baseline,
           DefaultBaseStyle->"RadioButtonBar"], 
          StyleBox[
           TemplateBox[{
             StyleBox["\" \"", "ProblemChoiceText", StripOnInput -> False], 
             StyleBox[
              Cell[
               TextData[{
                 StyleBox["data[Select[#c3>6&]]//Normal", "InlineFormula"]}]],
               "ProblemChoiceText", StripOnInput -> False]},
            "RowDefault"], "RadioButtonBarLabel",
           StripOnInput->False]}
        },
        AutoDelete->False,
        BaselinePosition->{1, 2},
        GridBoxAlignment->{"Columns" -> {{Left}}, "Rows" -> {{Baseline}}},
        GridBoxItemSize->{"Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}},
        GridBoxSpacings->{"Columns" -> {
            Offset[0.27999999999999997`], {
             Offset[0.21]}, 
            Offset[0.27999999999999997`]}, "Rows" -> {
            Offset[0.2], {
             Offset[0.4]}, 
            Offset[0.2]}}]},
      {GridBox[{
         {
          
          RadioButtonBox[Dynamic[
           MOOCNotebook`Quiz`Private`ans$$, (
            MOOCNotebook`Quiz`Private`ans$$ = #; SetOptions[
              EvaluationNotebook[], 
              TaggingRules -> {"Answers" -> Flatten[{ToString[4] -> #, 
                   DeleteCases[
                    CurrentValue[
                    EvaluationNotebook[], {TaggingRules, "Answers"}], 
                    ToString[4] -> Blank[]]}]}])& ], {4},
           BaselinePosition->Baseline,
           DefaultBaseStyle->"RadioButtonBar"], 
          StyleBox[
           TemplateBox[{
             StyleBox["\" \"", "ProblemChoiceText", StripOnInput -> False], 
             StyleBox[
              Cell[
               TextData[{
                 StyleBox["data[All, #c3>6&]//Normal", "InlineFormula"]}]], 
              "ProblemChoiceText", StripOnInput -> False]},
            "RowDefault"], "RadioButtonBarLabel",
           StripOnInput->False]}
        },
        AutoDelete->False,
        BaselinePosition->{1, 2},
        GridBoxAlignment->{"Columns" -> {{Left}}, "Rows" -> {{Baseline}}},
        GridBoxItemSize->{"Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}},
        GridBoxSpacings->{"Columns" -> {
            Offset[0.27999999999999997`], {
             Offset[0.21]}, 
            Offset[0.27999999999999997`]}, "Rows" -> {
            Offset[0.2], {
             Offset[0.4]}, 
            Offset[0.2]}}]}
     },
     GridBoxAlignment->{"Columns" -> {{Left}}, "Rows" -> {{Baseline}}}], 
    "Deploy"],
   RadioButtonBar[
    Dynamic[
    MOOCNotebook`Quiz`Private`ans$$, (MOOCNotebook`Quiz`Private`ans$$ = #; 
     SetOptions[
       EvaluationNotebook[], 
       TaggingRules -> {"Answers" -> Flatten[{ToString[4] -> #, 
            DeleteCases[
             CurrentValue[
              EvaluationNotebook[], {TaggingRules, "Answers"}], ToString[4] -> 
             Blank[]]}]}])& ], {1 -> Row[{
        Style[" ", "ProblemChoiceText"], 
        Style[
         RawBoxes[
          Cell[
           TextData[{
             StyleBox[
             "data[Select[#>6&], #c3&]//Normal", "InlineFormula"]}]]], 
         "ProblemChoiceText"]}], 2 -> Row[{
        Style[" ", "ProblemChoiceText"], 
        Style[
         RawBoxes[
          Cell[
           TextData[{
             StyleBox[
             "data[Select[#c3>6&], \"c3\"]//Normal", "InlineFormula"]}]]], 
         "ProblemChoiceText"]}], 3 -> Row[{
        Style[" ", "ProblemChoiceText"], 
        Style[
         RawBoxes[
          Cell[
           TextData[{
             StyleBox["data[Select[#c3>6&]]//Normal", "InlineFormula"]}]]], 
         "ProblemChoiceText"]}], 4 -> Row[{
        Style[" ", "ProblemChoiceText"], 
        Style[
         RawBoxes[
          Cell[
           TextData[{
             StyleBox["data[All, #c3>6&]//Normal", "InlineFormula"]}]]], 
         "ProblemChoiceText"]}]}, Appearance -> "Vertical", BaselinePosition -> 
    Baseline]],
  DynamicModuleValues:>{}]], "ProblemChoiceGrid"],

Cell["Problem 5", "ProblemSectionNoFeedback",
 TaggingRules->{"QuestionNum" -> "5"}],

Cell[TextData[{
 "After evaluating ",
 StyleBox["$Post=N", "InlineFormula"],
 ", which of the following is done for all later outputs?"
}], "ProblemCaption"],

Cell[BoxData[
 DynamicModuleBox[{MOOCNotebook`Quiz`Private`ans$$ = 0}, 
  InterpretationBox[
   StyleBox[GridBox[{
      {GridBox[{
         {
          
          RadioButtonBox[Dynamic[
           MOOCNotebook`Quiz`Private`ans$$, (
            MOOCNotebook`Quiz`Private`ans$$ = #; SetOptions[
              EvaluationNotebook[], 
              TaggingRules -> {"Answers" -> Flatten[{ToString[5] -> #, 
                   DeleteCases[
                    CurrentValue[
                    EvaluationNotebook[], {TaggingRules, "Answers"}], 
                    ToString[5] -> Blank[]]}]}])& ], {1},
           BaselinePosition->Baseline,
           DefaultBaseStyle->"RadioButtonBar"], 
          StyleBox[
           TemplateBox[{
             StyleBox["\" \"", "ProblemChoiceText", StripOnInput -> False], 
             StyleBox[
              Cell[
               TextData[{"The symbol ", 
                 StyleBox["N", "InlineFormula"], 
                 " is added to each output."}]], "ProblemChoiceText", 
              StripOnInput -> False]},
            "RowDefault"], "RadioButtonBarLabel",
           StripOnInput->False]}
        },
        AutoDelete->False,
        BaselinePosition->{1, 2},
        GridBoxAlignment->{"Columns" -> {{Left}}, "Rows" -> {{Baseline}}},
        GridBoxItemSize->{"Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}},
        GridBoxSpacings->{"Columns" -> {
            Offset[0.27999999999999997`], {
             Offset[0.21]}, 
            Offset[0.27999999999999997`]}, "Rows" -> {
            Offset[0.2], {
             Offset[0.4]}, 
            Offset[0.2]}}]},
      {GridBox[{
         {
          
          RadioButtonBox[Dynamic[
           MOOCNotebook`Quiz`Private`ans$$, (
            MOOCNotebook`Quiz`Private`ans$$ = #; SetOptions[
              EvaluationNotebook[], 
              TaggingRules -> {"Answers" -> Flatten[{ToString[5] -> #, 
                   DeleteCases[
                    CurrentValue[
                    EvaluationNotebook[], {TaggingRules, "Answers"}], 
                    ToString[5] -> Blank[]]}]}])& ], {2},
           BaselinePosition->Baseline,
           DefaultBaseStyle->"RadioButtonBar"], 
          StyleBox[
           TemplateBox[{
             StyleBox["\" \"", "ProblemChoiceText", StripOnInput -> False], 
             StyleBox[
              Cell[
              "Symbolic results are automatically turned into numerical \
results."], "ProblemChoiceText", StripOnInput -> False]},
            "RowDefault"], "RadioButtonBarLabel",
           StripOnInput->False]}
        },
        AutoDelete->False,
        BaselinePosition->{1, 2},
        GridBoxAlignment->{"Columns" -> {{Left}}, "Rows" -> {{Baseline}}},
        GridBoxItemSize->{"Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}},
        GridBoxSpacings->{"Columns" -> {
            Offset[0.27999999999999997`], {
             Offset[0.21]}, 
            Offset[0.27999999999999997`]}, "Rows" -> {
            Offset[0.2], {
             Offset[0.4]}, 
            Offset[0.2]}}]},
      {GridBox[{
         {
          
          RadioButtonBox[Dynamic[
           MOOCNotebook`Quiz`Private`ans$$, (
            MOOCNotebook`Quiz`Private`ans$$ = #; SetOptions[
              EvaluationNotebook[], 
              TaggingRules -> {"Answers" -> Flatten[{ToString[5] -> #, 
                   DeleteCases[
                    CurrentValue[
                    EvaluationNotebook[], {TaggingRules, "Answers"}], 
                    ToString[5] -> Blank[]]}]}])& ], {3},
           BaselinePosition->Baseline,
           DefaultBaseStyle->"RadioButtonBar"], 
          StyleBox[
           TemplateBox[{
             StyleBox["\" \"", "ProblemChoiceText", StripOnInput -> False], 
             StyleBox[
              Cell[
               TextData[{"The function ", 
                 StyleBox["N", "InlineFormula"], 
                 " is applied to each output."}]], "ProblemChoiceText", 
              StripOnInput -> False]},
            "RowDefault"], "RadioButtonBarLabel",
           StripOnInput->False]}
        },
        AutoDelete->False,
        BaselinePosition->{1, 2},
        GridBoxAlignment->{"Columns" -> {{Left}}, "Rows" -> {{Baseline}}},
        GridBoxItemSize->{"Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}},
        GridBoxSpacings->{"Columns" -> {
            Offset[0.27999999999999997`], {
             Offset[0.21]}, 
            Offset[0.27999999999999997`]}, "Rows" -> {
            Offset[0.2], {
             Offset[0.4]}, 
            Offset[0.2]}}]},
      {GridBox[{
         {
          
          RadioButtonBox[Dynamic[
           MOOCNotebook`Quiz`Private`ans$$, (
            MOOCNotebook`Quiz`Private`ans$$ = #; SetOptions[
              EvaluationNotebook[], 
              TaggingRules -> {"Answers" -> Flatten[{ToString[5] -> #, 
                   DeleteCases[
                    CurrentValue[
                    EvaluationNotebook[], {TaggingRules, "Answers"}], 
                    ToString[5] -> Blank[]]}]}])& ], {4},
           BaselinePosition->Baseline,
           DefaultBaseStyle->"RadioButtonBar"], 
          StyleBox[
           TemplateBox[{
             StyleBox["\" \"", "ProblemChoiceText", StripOnInput -> False], 
             StyleBox[
              Cell[
               TextData[{"Outputs are shown in base ", 
                 StyleBox["N", "InlineFormula"], "."}]], "ProblemChoiceText", 
              StripOnInput -> False]},
            "RowDefault"], "RadioButtonBarLabel",
           StripOnInput->False]}
        },
        AutoDelete->False,
        BaselinePosition->{1, 2},
        GridBoxAlignment->{"Columns" -> {{Left}}, "Rows" -> {{Baseline}}},
        GridBoxItemSize->{"Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}},
        GridBoxSpacings->{"Columns" -> {
            Offset[0.27999999999999997`], {
             Offset[0.21]}, 
            Offset[0.27999999999999997`]}, "Rows" -> {
            Offset[0.2], {
             Offset[0.4]}, 
            Offset[0.2]}}]}
     },
     GridBoxAlignment->{"Columns" -> {{Left}}, "Rows" -> {{Baseline}}}], 
    "Deploy"],
   RadioButtonBar[
    Dynamic[
    MOOCNotebook`Quiz`Private`ans$$, (MOOCNotebook`Quiz`Private`ans$$ = #; 
     SetOptions[
       EvaluationNotebook[], 
       TaggingRules -> {"Answers" -> Flatten[{ToString[5] -> #, 
            DeleteCases[
             CurrentValue[
              EvaluationNotebook[], {TaggingRules, "Answers"}], ToString[5] -> 
             Blank[]]}]}])& ], {1 -> Row[{
        Style[" ", "ProblemChoiceText"], 
        Style[
         RawBoxes[
          Cell[
           TextData[{"The symbol ", 
             StyleBox["N", "InlineFormula"], " is added to each output."}]]], 
         "ProblemChoiceText"]}], 2 -> Row[{
        Style[" ", "ProblemChoiceText"], 
        Style[
         RawBoxes[
          Cell[
          "Symbolic results are automatically turned into numerical \
results."]], "ProblemChoiceText"]}], 3 -> Row[{
        Style[" ", "ProblemChoiceText"], 
        Style[
         RawBoxes[
          Cell[
           TextData[{"The function ", 
             StyleBox["N", "InlineFormula"], 
             " is applied to each output."}]]], "ProblemChoiceText"]}], 4 -> 
     Row[{
        Style[" ", "ProblemChoiceText"], 
        Style[
         RawBoxes[
          Cell[
           TextData[{"Outputs are shown in base ", 
             StyleBox["N", "InlineFormula"], "."}]]], "ProblemChoiceText"]}]},
     Appearance -> "Vertical", BaselinePosition -> Baseline]],
  DynamicModuleValues:>{}]], "ProblemChoiceGrid"],

Cell["Problem 6", "ProblemSectionNoFeedback",
 TaggingRules->{"QuestionNum" -> "6"}],

Cell[TextData[{
 "Which of the following sets of three inputs creates a symbol ",
 StyleBox["newSymbol", "InlineFormula"],
 " in context ",
 StyleBox["newcontext`", "InlineFormula"],
 "?"
}], "ProblemCaption"],

Cell[BoxData[
 DynamicModuleBox[{MOOCNotebook`Quiz`Private`ans$$ = 0}, 
  InterpretationBox[
   StyleBox[GridBox[{
      {GridBox[{
         {
          
          RadioButtonBox[Dynamic[
           MOOCNotebook`Quiz`Private`ans$$, (
            MOOCNotebook`Quiz`Private`ans$$ = #; SetOptions[
              EvaluationNotebook[], 
              TaggingRules -> {"Answers" -> Flatten[{ToString[6] -> #, 
                   DeleteCases[
                    CurrentValue[
                    EvaluationNotebook[], {TaggingRules, "Answers"}], 
                    ToString[6] -> Blank[]]}]}])& ], {1},
           BaselinePosition->Baseline,
           DefaultBaseStyle->"RadioButtonBar"], 
          StyleBox[
           TemplateBox[{
             StyleBox["\" \"", "ProblemChoiceText", StripOnInput -> False], 
             StyleBox[
              Cell[
               TextData[{
                 StyleBox[
                 "Start[\"newcontext`\"]\n  newSymbol\n  End[]", 
                  "InlineFormula"]}]], "ProblemChoiceText", StripOnInput -> 
              False]},
            "RowDefault"], "RadioButtonBarLabel",
           StripOnInput->False]}
        },
        AutoDelete->False,
        BaselinePosition->{1, 2},
        GridBoxAlignment->{"Columns" -> {{Left}}, "Rows" -> {{Baseline}}},
        GridBoxItemSize->{"Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}},
        GridBoxSpacings->{"Columns" -> {
            Offset[0.27999999999999997`], {
             Offset[0.21]}, 
            Offset[0.27999999999999997`]}, "Rows" -> {
            Offset[0.2], {
             Offset[0.4]}, 
            Offset[0.2]}}]},
      {GridBox[{
         {
          
          RadioButtonBox[Dynamic[
           MOOCNotebook`Quiz`Private`ans$$, (
            MOOCNotebook`Quiz`Private`ans$$ = #; SetOptions[
              EvaluationNotebook[], 
              TaggingRules -> {"Answers" -> Flatten[{ToString[6] -> #, 
                   DeleteCases[
                    CurrentValue[
                    EvaluationNotebook[], {TaggingRules, "Answers"}], 
                    ToString[6] -> Blank[]]}]}])& ], {2},
           BaselinePosition->Baseline,
           DefaultBaseStyle->"RadioButtonBar"], 
          StyleBox[
           TemplateBox[{
             StyleBox["\" \"", "ProblemChoiceText", StripOnInput -> False], 
             StyleBox[
              Cell[
               TextData[{
                 StyleBox[
                 "Begin[\"newcontext\"]\n  newSymbol\n  End[]", 
                  "InlineFormula"]}]], "ProblemChoiceText", StripOnInput -> 
              False]},
            "RowDefault"], "RadioButtonBarLabel",
           StripOnInput->False]}
        },
        AutoDelete->False,
        BaselinePosition->{1, 2},
        GridBoxAlignment->{"Columns" -> {{Left}}, "Rows" -> {{Baseline}}},
        GridBoxItemSize->{"Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}},
        GridBoxSpacings->{"Columns" -> {
            Offset[0.27999999999999997`], {
             Offset[0.21]}, 
            Offset[0.27999999999999997`]}, "Rows" -> {
            Offset[0.2], {
             Offset[0.4]}, 
            Offset[0.2]}}]},
      {GridBox[{
         {
          
          RadioButtonBox[Dynamic[
           MOOCNotebook`Quiz`Private`ans$$, (
            MOOCNotebook`Quiz`Private`ans$$ = #; SetOptions[
              EvaluationNotebook[], 
              TaggingRules -> {"Answers" -> Flatten[{ToString[6] -> #, 
                   DeleteCases[
                    CurrentValue[
                    EvaluationNotebook[], {TaggingRules, "Answers"}], 
                    ToString[6] -> Blank[]]}]}])& ], {3},
           BaselinePosition->Baseline,
           DefaultBaseStyle->"RadioButtonBar"], 
          StyleBox[
           TemplateBox[{
             StyleBox["\" \"", "ProblemChoiceText", StripOnInput -> False], 
             StyleBox[
              Cell[
               TextData[{
                 StyleBox[
                 "Begin[\"newcontext`\"]\n  newSymbol\n  End[] ", 
                  "InlineFormula"]}]], "ProblemChoiceText", StripOnInput -> 
              False]},
            "RowDefault"], "RadioButtonBarLabel",
           StripOnInput->False]}
        },
        AutoDelete->False,
        BaselinePosition->{1, 2},
        GridBoxAlignment->{"Columns" -> {{Left}}, "Rows" -> {{Baseline}}},
        GridBoxItemSize->{"Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}},
        GridBoxSpacings->{"Columns" -> {
            Offset[0.27999999999999997`], {
             Offset[0.21]}, 
            Offset[0.27999999999999997`]}, "Rows" -> {
            Offset[0.2], {
             Offset[0.4]}, 
            Offset[0.2]}}]},
      {GridBox[{
         {
          
          RadioButtonBox[Dynamic[
           MOOCNotebook`Quiz`Private`ans$$, (
            MOOCNotebook`Quiz`Private`ans$$ = #; SetOptions[
              EvaluationNotebook[], 
              TaggingRules -> {"Answers" -> Flatten[{ToString[6] -> #, 
                   DeleteCases[
                    CurrentValue[
                    EvaluationNotebook[], {TaggingRules, "Answers"}], 
                    ToString[6] -> Blank[]]}]}])& ], {4},
           BaselinePosition->Baseline,
           DefaultBaseStyle->"RadioButtonBar"], 
          StyleBox[
           TemplateBox[{
             StyleBox["\" \"", "ProblemChoiceText", StripOnInput -> False], 
             StyleBox[
              Cell[
               TextData[{
                 StyleBox[
                 "newcontext`\n  newSymbol\n  End[]", "InlineFormula"]}]], 
              "ProblemChoiceText", StripOnInput -> False]},
            "RowDefault"], "RadioButtonBarLabel",
           StripOnInput->False]}
        },
        AutoDelete->False,
        BaselinePosition->{1, 2},
        GridBoxAlignment->{"Columns" -> {{Left}}, "Rows" -> {{Baseline}}},
        GridBoxItemSize->{"Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}},
        GridBoxSpacings->{"Columns" -> {
            Offset[0.27999999999999997`], {
             Offset[0.21]}, 
            Offset[0.27999999999999997`]}, "Rows" -> {
            Offset[0.2], {
             Offset[0.4]}, 
            Offset[0.2]}}]}
     },
     GridBoxAlignment->{"Columns" -> {{Left}}, "Rows" -> {{Baseline}}}], 
    "Deploy"],
   RadioButtonBar[
    Dynamic[
    MOOCNotebook`Quiz`Private`ans$$, (MOOCNotebook`Quiz`Private`ans$$ = #; 
     SetOptions[
       EvaluationNotebook[], 
       TaggingRules -> {"Answers" -> Flatten[{ToString[6] -> #, 
            DeleteCases[
             CurrentValue[
              EvaluationNotebook[], {TaggingRules, "Answers"}], ToString[6] -> 
             Blank[]]}]}])& ], {1 -> Row[{
        Style[" ", "ProblemChoiceText"], 
        Style[
         RawBoxes[
          Cell[
           TextData[{
             StyleBox[
             "Start[\"newcontext`\"]\n  newSymbol\n  End[]", 
              "InlineFormula"]}]]], "ProblemChoiceText"]}], 2 -> Row[{
        Style[" ", "ProblemChoiceText"], 
        Style[
         RawBoxes[
          Cell[
           TextData[{
             StyleBox[
             "Begin[\"newcontext\"]\n  newSymbol\n  End[]", 
              "InlineFormula"]}]]], "ProblemChoiceText"]}], 3 -> Row[{
        Style[" ", "ProblemChoiceText"], 
        Style[
         RawBoxes[
          Cell[
           TextData[{
             StyleBox[
             "Begin[\"newcontext`\"]\n  newSymbol\n  End[] ", 
              "InlineFormula"]}]]], "ProblemChoiceText"]}], 4 -> Row[{
        Style[" ", "ProblemChoiceText"], 
        Style[
         RawBoxes[
          Cell[
           TextData[{
             StyleBox[
             "newcontext`\n  newSymbol\n  End[]", "InlineFormula"]}]]], 
         "ProblemChoiceText"]}]}, Appearance -> "Vertical", BaselinePosition -> 
    Baseline]],
  DynamicModuleValues:>{}]], "ProblemChoiceGrid"],

Cell["Problem 7", "ProblemSectionNoFeedback",
 TaggingRules->{"QuestionNum" -> "7"}],

Cell[TextData[{
 "After evaluating (or loading a package that contains) these inputs:\n\n",
 StyleBox["Begin[\"mycontext`\"];\nnewFunction[x_]:=x+2\nEnd[];", 
  "InlineFormula"],
 "\n\nwhich of the following shows a valid way of using ",
 StyleBox["newFunction", "InlineFormula"],
 "?"
}], "ProblemCaption"],

Cell[BoxData[
 DynamicModuleBox[{MOOCNotebook`Quiz`Private`ans$$ = 0}, 
  InterpretationBox[
   StyleBox[GridBox[{
      {GridBox[{
         {
          
          RadioButtonBox[Dynamic[
           MOOCNotebook`Quiz`Private`ans$$, (
            MOOCNotebook`Quiz`Private`ans$$ = #; SetOptions[
              EvaluationNotebook[], 
              TaggingRules -> {"Answers" -> Flatten[{ToString[7] -> #, 
                   DeleteCases[
                    CurrentValue[
                    EvaluationNotebook[], {TaggingRules, "Answers"}], 
                    ToString[7] -> Blank[]]}]}])& ], {1},
           BaselinePosition->Baseline,
           DefaultBaseStyle->"RadioButtonBar"], 
          StyleBox[
           TemplateBox[{
             StyleBox["\" \"", "ProblemChoiceText", StripOnInput -> False], 
             StyleBox[
              Cell[
               TextData[{
                 StyleBox["newFunction[10]", "InlineFormula"]}]], 
              "ProblemChoiceText", StripOnInput -> False]},
            "RowDefault"], "RadioButtonBarLabel",
           StripOnInput->False]}
        },
        AutoDelete->False,
        BaselinePosition->{1, 2},
        GridBoxAlignment->{"Columns" -> {{Left}}, "Rows" -> {{Baseline}}},
        GridBoxItemSize->{"Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}},
        GridBoxSpacings->{"Columns" -> {
            Offset[0.27999999999999997`], {
             Offset[0.21]}, 
            Offset[0.27999999999999997`]}, "Rows" -> {
            Offset[0.2], {
             Offset[0.4]}, 
            Offset[0.2]}}]},
      {GridBox[{
         {
          
          RadioButtonBox[Dynamic[
           MOOCNotebook`Quiz`Private`ans$$, (
            MOOCNotebook`Quiz`Private`ans$$ = #; SetOptions[
              EvaluationNotebook[], 
              TaggingRules -> {"Answers" -> Flatten[{ToString[7] -> #, 
                   DeleteCases[
                    CurrentValue[
                    EvaluationNotebook[], {TaggingRules, "Answers"}], 
                    ToString[7] -> Blank[]]}]}])& ], {2},
           BaselinePosition->Baseline,
           DefaultBaseStyle->"RadioButtonBar"], 
          StyleBox[
           TemplateBox[{
             StyleBox["\" \"", "ProblemChoiceText", StripOnInput -> False], 
             StyleBox[
              Cell[
               TextData[{
                 StyleBox["mycontext`newFunction[10]", "InlineFormula"]}]], 
              "ProblemChoiceText", StripOnInput -> False]},
            "RowDefault"], "RadioButtonBarLabel",
           StripOnInput->False]}
        },
        AutoDelete->False,
        BaselinePosition->{1, 2},
        GridBoxAlignment->{"Columns" -> {{Left}}, "Rows" -> {{Baseline}}},
        GridBoxItemSize->{"Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}},
        GridBoxSpacings->{"Columns" -> {
            Offset[0.27999999999999997`], {
             Offset[0.21]}, 
            Offset[0.27999999999999997`]}, "Rows" -> {
            Offset[0.2], {
             Offset[0.4]}, 
            Offset[0.2]}}]},
      {GridBox[{
         {
          
          RadioButtonBox[Dynamic[
           MOOCNotebook`Quiz`Private`ans$$, (
            MOOCNotebook`Quiz`Private`ans$$ = #; SetOptions[
              EvaluationNotebook[], 
              TaggingRules -> {"Answers" -> Flatten[{ToString[7] -> #, 
                   DeleteCases[
                    CurrentValue[
                    EvaluationNotebook[], {TaggingRules, "Answers"}], 
                    ToString[7] -> Blank[]]}]}])& ], {3},
           BaselinePosition->Baseline,
           DefaultBaseStyle->"RadioButtonBar"], 
          StyleBox[
           TemplateBox[{
             StyleBox["\" \"", "ProblemChoiceText", StripOnInput -> False], 
             StyleBox[
              Cell[
               TextData[{
                 StyleBox[
                 "Begin[\"mycontext`\"]; newFunction[10]", 
                  "InlineFormula"]}]], "ProblemChoiceText", StripOnInput -> 
              False]},
            "RowDefault"], "RadioButtonBarLabel",
           StripOnInput->False]}
        },
        AutoDelete->False,
        BaselinePosition->{1, 2},
        GridBoxAlignment->{"Columns" -> {{Left}}, "Rows" -> {{Baseline}}},
        GridBoxItemSize->{"Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}},
        GridBoxSpacings->{"Columns" -> {
            Offset[0.27999999999999997`], {
             Offset[0.21]}, 
            Offset[0.27999999999999997`]}, "Rows" -> {
            Offset[0.2], {
             Offset[0.4]}, 
            Offset[0.2]}}]},
      {GridBox[{
         {
          
          RadioButtonBox[Dynamic[
           MOOCNotebook`Quiz`Private`ans$$, (
            MOOCNotebook`Quiz`Private`ans$$ = #; SetOptions[
              EvaluationNotebook[], 
              TaggingRules -> {"Answers" -> Flatten[{ToString[7] -> #, 
                   DeleteCases[
                    CurrentValue[
                    EvaluationNotebook[], {TaggingRules, "Answers"}], 
                    ToString[7] -> Blank[]]}]}])& ], {4},
           BaselinePosition->Baseline,
           DefaultBaseStyle->"RadioButtonBar"], 
          StyleBox[
           TemplateBox[{
             StyleBox["\" \"", "ProblemChoiceText", StripOnInput -> False], 
             StyleBox[
              Cell[
               TextData[{
                 StyleBox[
                 "Begin[mycontext`newFunction[10]]", "InlineFormula"]}]], 
              "ProblemChoiceText", StripOnInput -> False]},
            "RowDefault"], "RadioButtonBarLabel",
           StripOnInput->False]}
        },
        AutoDelete->False,
        BaselinePosition->{1, 2},
        GridBoxAlignment->{"Columns" -> {{Left}}, "Rows" -> {{Baseline}}},
        GridBoxItemSize->{"Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}},
        GridBoxSpacings->{"Columns" -> {
            Offset[0.27999999999999997`], {
             Offset[0.21]}, 
            Offset[0.27999999999999997`]}, "Rows" -> {
            Offset[0.2], {
             Offset[0.4]}, 
            Offset[0.2]}}]}
     },
     GridBoxAlignment->{"Columns" -> {{Left}}, "Rows" -> {{Baseline}}}], 
    "Deploy"],
   RadioButtonBar[
    Dynamic[
    MOOCNotebook`Quiz`Private`ans$$, (MOOCNotebook`Quiz`Private`ans$$ = #; 
     SetOptions[
       EvaluationNotebook[], 
       TaggingRules -> {"Answers" -> Flatten[{ToString[7] -> #, 
            DeleteCases[
             CurrentValue[
              EvaluationNotebook[], {TaggingRules, "Answers"}], ToString[7] -> 
             Blank[]]}]}])& ], {1 -> Row[{
        Style[" ", "ProblemChoiceText"], 
        Style[
         RawBoxes[
          Cell[
           TextData[{
             StyleBox["newFunction[10]", "InlineFormula"]}]]], 
         "ProblemChoiceText"]}], 2 -> Row[{
        Style[" ", "ProblemChoiceText"], 
        Style[
         RawBoxes[
          Cell[
           TextData[{
             StyleBox["mycontext`newFunction[10]", "InlineFormula"]}]]], 
         "ProblemChoiceText"]}], 3 -> Row[{
        Style[" ", "ProblemChoiceText"], 
        Style[
         RawBoxes[
          Cell[
           TextData[{
             StyleBox[
             "Begin[\"mycontext`\"]; newFunction[10]", "InlineFormula"]}]]], 
         "ProblemChoiceText"]}], 4 -> Row[{
        Style[" ", "ProblemChoiceText"], 
        Style[
         RawBoxes[
          Cell[
           TextData[{
             StyleBox[
             "Begin[mycontext`newFunction[10]]", "InlineFormula"]}]]], 
         "ProblemChoiceText"]}]}, Appearance -> "Vertical", BaselinePosition -> 
    Baseline]],
  DynamicModuleValues:>{}]], "ProblemChoiceGrid"],

Cell["Problem 8", "ProblemSectionNoFeedback",
 TaggingRules->{"QuestionNum" -> "8"}],

Cell[TextData[{
 "Assuming that there is a package ",
 StyleBox["ImportantPackage`", "InlineFormula"],
 " with the recommended structure and file name, which of the following is ",
 StyleBox["not",
  FontSlant->"Italic"],
 " a correct way to load the package?"
}], "ProblemCaption"],

Cell[BoxData[
 DynamicModuleBox[{MOOCNotebook`Quiz`Private`ans$$ = 0}, 
  InterpretationBox[
   StyleBox[GridBox[{
      {GridBox[{
         {
          
          RadioButtonBox[Dynamic[
           MOOCNotebook`Quiz`Private`ans$$, (
            MOOCNotebook`Quiz`Private`ans$$ = #; SetOptions[
              EvaluationNotebook[], 
              TaggingRules -> {"Answers" -> Flatten[{ToString[8] -> #, 
                   DeleteCases[
                    CurrentValue[
                    EvaluationNotebook[], {TaggingRules, "Answers"}], 
                    ToString[8] -> Blank[]]}]}])& ], {1},
           BaselinePosition->Baseline,
           DefaultBaseStyle->"RadioButtonBar"], 
          StyleBox[
           TemplateBox[{
             StyleBox["\" \"", "ProblemChoiceText", StripOnInput -> False], 
             StyleBox[
              Cell[
               TextData[{
                 StyleBox["Needs[\"ImportantPackage`\"]", "InlineFormula"]}]],
               "ProblemChoiceText", StripOnInput -> False]},
            "RowDefault"], "RadioButtonBarLabel",
           StripOnInput->False]}
        },
        AutoDelete->False,
        BaselinePosition->{1, 2},
        GridBoxAlignment->{"Columns" -> {{Left}}, "Rows" -> {{Baseline}}},
        GridBoxItemSize->{"Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}},
        GridBoxSpacings->{"Columns" -> {
            Offset[0.27999999999999997`], {
             Offset[0.21]}, 
            Offset[0.27999999999999997`]}, "Rows" -> {
            Offset[0.2], {
             Offset[0.4]}, 
            Offset[0.2]}}]},
      {GridBox[{
         {
          
          RadioButtonBox[Dynamic[
           MOOCNotebook`Quiz`Private`ans$$, (
            MOOCNotebook`Quiz`Private`ans$$ = #; SetOptions[
              EvaluationNotebook[], 
              TaggingRules -> {"Answers" -> Flatten[{ToString[8] -> #, 
                   DeleteCases[
                    CurrentValue[
                    EvaluationNotebook[], {TaggingRules, "Answers"}], 
                    ToString[8] -> Blank[]]}]}])& ], {2},
           BaselinePosition->Baseline,
           DefaultBaseStyle->"RadioButtonBar"], 
          StyleBox[
           TemplateBox[{
             StyleBox["\" \"", "ProblemChoiceText", StripOnInput -> False], 
             StyleBox[
              Cell[
               TextData[{
                 StyleBox["Get[\"ImportantPackage`\"]", "InlineFormula"]}]], 
              "ProblemChoiceText", StripOnInput -> False]},
            "RowDefault"], "RadioButtonBarLabel",
           StripOnInput->False]}
        },
        AutoDelete->False,
        BaselinePosition->{1, 2},
        GridBoxAlignment->{"Columns" -> {{Left}}, "Rows" -> {{Baseline}}},
        GridBoxItemSize->{"Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}},
        GridBoxSpacings->{"Columns" -> {
            Offset[0.27999999999999997`], {
             Offset[0.21]}, 
            Offset[0.27999999999999997`]}, "Rows" -> {
            Offset[0.2], {
             Offset[0.4]}, 
            Offset[0.2]}}]},
      {GridBox[{
         {
          
          RadioButtonBox[Dynamic[
           MOOCNotebook`Quiz`Private`ans$$, (
            MOOCNotebook`Quiz`Private`ans$$ = #; SetOptions[
              EvaluationNotebook[], 
              TaggingRules -> {"Answers" -> Flatten[{ToString[8] -> #, 
                   DeleteCases[
                    CurrentValue[
                    EvaluationNotebook[], {TaggingRules, "Answers"}], 
                    ToString[8] -> Blank[]]}]}])& ], {3},
           BaselinePosition->Baseline,
           DefaultBaseStyle->"RadioButtonBar"], 
          StyleBox[
           TemplateBox[{
             StyleBox["\" \"", "ProblemChoiceText", StripOnInput -> False], 
             StyleBox[
              Cell[
               TextData[{
                 StyleBox[
                 "Import[\"ImportantPackage`\"]", "InlineFormula"]}]], 
              "ProblemChoiceText", StripOnInput -> False]},
            "RowDefault"], "RadioButtonBarLabel",
           StripOnInput->False]}
        },
        AutoDelete->False,
        BaselinePosition->{1, 2},
        GridBoxAlignment->{"Columns" -> {{Left}}, "Rows" -> {{Baseline}}},
        GridBoxItemSize->{"Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}},
        GridBoxSpacings->{"Columns" -> {
            Offset[0.27999999999999997`], {
             Offset[0.21]}, 
            Offset[0.27999999999999997`]}, "Rows" -> {
            Offset[0.2], {
             Offset[0.4]}, 
            Offset[0.2]}}]},
      {GridBox[{
         {
          
          RadioButtonBox[Dynamic[
           MOOCNotebook`Quiz`Private`ans$$, (
            MOOCNotebook`Quiz`Private`ans$$ = #; SetOptions[
              EvaluationNotebook[], 
              TaggingRules -> {"Answers" -> Flatten[{ToString[8] -> #, 
                   DeleteCases[
                    CurrentValue[
                    EvaluationNotebook[], {TaggingRules, "Answers"}], 
                    ToString[8] -> Blank[]]}]}])& ], {4},
           BaselinePosition->Baseline,
           DefaultBaseStyle->"RadioButtonBar"], 
          StyleBox[
           TemplateBox[{
             StyleBox["\" \"", "ProblemChoiceText", StripOnInput -> False], 
             StyleBox[
              Cell[
               TextData[{
                 StyleBox["<<\"ImportantPackage`\"", "InlineFormula"]}]], 
              "ProblemChoiceText", StripOnInput -> False]},
            "RowDefault"], "RadioButtonBarLabel",
           StripOnInput->False]}
        },
        AutoDelete->False,
        BaselinePosition->{1, 2},
        GridBoxAlignment->{"Columns" -> {{Left}}, "Rows" -> {{Baseline}}},
        GridBoxItemSize->{"Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}},
        GridBoxSpacings->{"Columns" -> {
            Offset[0.27999999999999997`], {
             Offset[0.21]}, 
            Offset[0.27999999999999997`]}, "Rows" -> {
            Offset[0.2], {
             Offset[0.4]}, 
            Offset[0.2]}}]}
     },
     GridBoxAlignment->{"Columns" -> {{Left}}, "Rows" -> {{Baseline}}}], 
    "Deploy"],
   RadioButtonBar[
    Dynamic[
    MOOCNotebook`Quiz`Private`ans$$, (MOOCNotebook`Quiz`Private`ans$$ = #; 
     SetOptions[
       EvaluationNotebook[], 
       TaggingRules -> {"Answers" -> Flatten[{ToString[8] -> #, 
            DeleteCases[
             CurrentValue[
              EvaluationNotebook[], {TaggingRules, "Answers"}], ToString[8] -> 
             Blank[]]}]}])& ], {1 -> Row[{
        Style[" ", "ProblemChoiceText"], 
        Style[
         RawBoxes[
          Cell[
           TextData[{
             StyleBox["Needs[\"ImportantPackage`\"]", "InlineFormula"]}]]], 
         "ProblemChoiceText"]}], 2 -> Row[{
        Style[" ", "ProblemChoiceText"], 
        Style[
         RawBoxes[
          Cell[
           TextData[{
             StyleBox["Get[\"ImportantPackage`\"]", "InlineFormula"]}]]], 
         "ProblemChoiceText"]}], 3 -> Row[{
        Style[" ", "ProblemChoiceText"], 
        Style[
         RawBoxes[
          Cell[
           TextData[{
             StyleBox["Import[\"ImportantPackage`\"]", "InlineFormula"]}]]], 
         "ProblemChoiceText"]}], 4 -> Row[{
        Style[" ", "ProblemChoiceText"], 
        Style[
         RawBoxes[
          Cell[
           TextData[{
             StyleBox["<<\"ImportantPackage`\"", "InlineFormula"]}]]], 
         "ProblemChoiceText"]}]}, Appearance -> "Vertical", BaselinePosition -> 
    Baseline]],
  DynamicModuleValues:>{}]], "ProblemChoiceGrid"],

Cell["Problem 9", "ProblemSectionNoFeedback",
 TaggingRules->{"QuestionNum" -> "9"}],

Cell["What is the output of this program?", "ProblemCaption"],

Cell[BoxData[{
 StyleBox[
  RowBox[{"Clear", "[", "myF", "]"}], "InlineFormula"], "\n", 
 StyleBox[
  RowBox[{
   RowBox[{
    RowBox[{"myF", "[", "n_", "]"}], " ", ":=", " ", 
    RowBox[{"2", " ", "n"}]}], ";"}], "InlineFormula"], "\n", 
 StyleBox[
  RowBox[{
   RowBox[{"BeginPackage", "[", "\"\<mypackage`\>\"", "]"}], ";"}], 
  "InlineFormula"], "\n", 
 StyleBox[
  RowBox[{
   RowBox[{"Begin", "[", "\"\<`Private`\>\"", "]"}], ";"}], 
  "InlineFormula"], "\n", 
 StyleBox[
  RowBox[{
   RowBox[{
    RowBox[{"myF", "[", "n_", "]"}], " ", ":=", " ", 
    RowBox[{"100", " ", "n"}]}], ";"}], "InlineFormula"], "\n", 
 StyleBox[
  RowBox[{
   RowBox[{"End", "[", "]"}], ";"}], "InlineFormula"], "\n", 
 StyleBox[
  RowBox[{
   RowBox[{"EndPackage", "[", "]"}], ";"}], "InlineFormula"], "\n", 
 StyleBox[
  RowBox[{"myF", "[", "7", "]"}], "InlineFormula"]}], "Input",
 CellChangeTimes->{{3.792414871682647*^9, 3.7924148891582174`*^9}, 
   3.792854277924472*^9, {3.798388089805148*^9, 3.798388130763404*^9}, {
   3.7983881669783783`*^9, 3.798388276573763*^9}, {3.798388324333908*^9, 
   3.798388418026703*^9}, {3.798388517849009*^9, 3.7983885280000973`*^9}, {
   3.7989881883224173`*^9, 3.798988202054063*^9}}],

Cell[BoxData[
 DynamicModuleBox[{MOOCNotebook`Quiz`Private`ans$$ = 0}, 
  InterpretationBox[
   StyleBox[GridBox[{
      {GridBox[{
         {
          
          RadioButtonBox[Dynamic[
           MOOCNotebook`Quiz`Private`ans$$, (
            MOOCNotebook`Quiz`Private`ans$$ = #; SetOptions[
              EvaluationNotebook[], 
              TaggingRules -> {"Answers" -> Flatten[{ToString[9] -> #, 
                   DeleteCases[
                    CurrentValue[
                    EvaluationNotebook[], {TaggingRules, "Answers"}], 
                    ToString[9] -> Blank[]]}]}])& ], {1},
           BaselinePosition->Baseline,
           DefaultBaseStyle->"RadioButtonBar"], 
          StyleBox[
           TemplateBox[{
             StyleBox["\" \"", "ProblemChoiceText", StripOnInput -> False], 
             StyleBox[
              Cell[
               TextData[{
                 StyleBox["myF[7]", "InlineFormula"]}]], "ProblemChoiceText", 
              StripOnInput -> False]},
            "RowDefault"], "RadioButtonBarLabel",
           StripOnInput->False]}
        },
        AutoDelete->False,
        BaselinePosition->{1, 2},
        GridBoxAlignment->{"Columns" -> {{Left}}, "Rows" -> {{Baseline}}},
        GridBoxItemSize->{"Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}},
        GridBoxSpacings->{"Columns" -> {
            Offset[0.27999999999999997`], {
             Offset[0.21]}, 
            Offset[0.27999999999999997`]}, "Rows" -> {
            Offset[0.2], {
             Offset[0.4]}, 
            Offset[0.2]}}]},
      {GridBox[{
         {
          
          RadioButtonBox[Dynamic[
           MOOCNotebook`Quiz`Private`ans$$, (
            MOOCNotebook`Quiz`Private`ans$$ = #; SetOptions[
              EvaluationNotebook[], 
              TaggingRules -> {"Answers" -> Flatten[{ToString[9] -> #, 
                   DeleteCases[
                    CurrentValue[
                    EvaluationNotebook[], {TaggingRules, "Answers"}], 
                    ToString[9] -> Blank[]]}]}])& ], {2},
           BaselinePosition->Baseline,
           DefaultBaseStyle->"RadioButtonBar"], 
          StyleBox[
           TemplateBox[{
             StyleBox["\" \"", "ProblemChoiceText", StripOnInput -> False], 
             StyleBox[
              Cell["7"], "ProblemChoiceText", StripOnInput -> False]},
            "RowDefault"], "RadioButtonBarLabel",
           StripOnInput->False]}
        },
        AutoDelete->False,
        BaselinePosition->{1, 2},
        GridBoxAlignment->{"Columns" -> {{Left}}, "Rows" -> {{Baseline}}},
        GridBoxItemSize->{"Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}},
        GridBoxSpacings->{"Columns" -> {
            Offset[0.27999999999999997`], {
             Offset[0.21]}, 
            Offset[0.27999999999999997`]}, "Rows" -> {
            Offset[0.2], {
             Offset[0.4]}, 
            Offset[0.2]}}]},
      {GridBox[{
         {
          
          RadioButtonBox[Dynamic[
           MOOCNotebook`Quiz`Private`ans$$, (
            MOOCNotebook`Quiz`Private`ans$$ = #; SetOptions[
              EvaluationNotebook[], 
              TaggingRules -> {"Answers" -> Flatten[{ToString[9] -> #, 
                   DeleteCases[
                    CurrentValue[
                    EvaluationNotebook[], {TaggingRules, "Answers"}], 
                    ToString[9] -> Blank[]]}]}])& ], {3},
           BaselinePosition->Baseline,
           DefaultBaseStyle->"RadioButtonBar"], 
          StyleBox[
           TemplateBox[{
             StyleBox["\" \"", "ProblemChoiceText", StripOnInput -> False], 
             StyleBox[
              Cell[
               TextData[{
                 StyleBox["14", "InlineFormula"]}]], "ProblemChoiceText", 
              StripOnInput -> False]},
            "RowDefault"], "RadioButtonBarLabel",
           StripOnInput->False]}
        },
        AutoDelete->False,
        BaselinePosition->{1, 2},
        GridBoxAlignment->{"Columns" -> {{Left}}, "Rows" -> {{Baseline}}},
        GridBoxItemSize->{"Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}},
        GridBoxSpacings->{"Columns" -> {
            Offset[0.27999999999999997`], {
             Offset[0.21]}, 
            Offset[0.27999999999999997`]}, "Rows" -> {
            Offset[0.2], {
             Offset[0.4]}, 
            Offset[0.2]}}]},
      {GridBox[{
         {
          
          RadioButtonBox[Dynamic[
           MOOCNotebook`Quiz`Private`ans$$, (
            MOOCNotebook`Quiz`Private`ans$$ = #; SetOptions[
              EvaluationNotebook[], 
              TaggingRules -> {"Answers" -> Flatten[{ToString[9] -> #, 
                   DeleteCases[
                    CurrentValue[
                    EvaluationNotebook[], {TaggingRules, "Answers"}], 
                    ToString[9] -> Blank[]]}]}])& ], {4},
           BaselinePosition->Baseline,
           DefaultBaseStyle->"RadioButtonBar"], 
          StyleBox[
           TemplateBox[{
             StyleBox["\" \"", "ProblemChoiceText", StripOnInput -> False], 
             StyleBox[
              Cell[
               TextData[{
                 StyleBox["700", "InlineFormula"]}]], "ProblemChoiceText", 
              StripOnInput -> False]},
            "RowDefault"], "RadioButtonBarLabel",
           StripOnInput->False]}
        },
        AutoDelete->False,
        BaselinePosition->{1, 2},
        GridBoxAlignment->{"Columns" -> {{Left}}, "Rows" -> {{Baseline}}},
        GridBoxItemSize->{"Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}},
        GridBoxSpacings->{"Columns" -> {
            Offset[0.27999999999999997`], {
             Offset[0.21]}, 
            Offset[0.27999999999999997`]}, "Rows" -> {
            Offset[0.2], {
             Offset[0.4]}, 
            Offset[0.2]}}]}
     },
     GridBoxAlignment->{"Columns" -> {{Left}}, "Rows" -> {{Baseline}}}], 
    "Deploy"],
   RadioButtonBar[
    Dynamic[
    MOOCNotebook`Quiz`Private`ans$$, (MOOCNotebook`Quiz`Private`ans$$ = #; 
     SetOptions[
       EvaluationNotebook[], 
       TaggingRules -> {"Answers" -> Flatten[{ToString[9] -> #, 
            DeleteCases[
             CurrentValue[
              EvaluationNotebook[], {TaggingRules, "Answers"}], ToString[9] -> 
             Blank[]]}]}])& ], {1 -> Row[{
        Style[" ", "ProblemChoiceText"], 
        Style[
         RawBoxes[
          Cell[
           TextData[{
             StyleBox["myF[7]", "InlineFormula"]}]]], "ProblemChoiceText"]}], 
     2 -> Row[{
        Style[" ", "ProblemChoiceText"], 
        Style[
         RawBoxes[
          Cell["7"]], "ProblemChoiceText"]}], 3 -> Row[{
        Style[" ", "ProblemChoiceText"], 
        Style[
         RawBoxes[
          Cell[
           TextData[{
             StyleBox["14", "InlineFormula"]}]]], "ProblemChoiceText"]}], 4 -> 
     Row[{
        Style[" ", "ProblemChoiceText"], 
        Style[
         RawBoxes[
          Cell[
           TextData[{
             StyleBox["700", "InlineFormula"]}]]], "ProblemChoiceText"]}]}, 
    Appearance -> "Vertical", BaselinePosition -> Baseline]],
  DynamicModuleValues:>{}]], "ProblemChoiceGrid"],

Cell["Problem 10", "ProblemSectionNoFeedback",
 TaggingRules->{"QuestionNum" -> "10"}],

Cell["Complete the following statement about Wolfram Workbench\[Trademark].", \
"ProblemCaption"],

Cell["\<\
Wolfram Workbench ______________________________________________.\
\>", "ProblemCaption"],

Cell[BoxData[
 DynamicModuleBox[{MOOCNotebook`Quiz`Private`ans$$ = 0}, 
  InterpretationBox[
   StyleBox[GridBox[{
      {GridBox[{
         {
          
          RadioButtonBox[Dynamic[
           MOOCNotebook`Quiz`Private`ans$$, (
            MOOCNotebook`Quiz`Private`ans$$ = #; SetOptions[
              EvaluationNotebook[], 
              TaggingRules -> {"Answers" -> Flatten[{ToString[10] -> #, 
                   DeleteCases[
                    CurrentValue[
                    EvaluationNotebook[], {TaggingRules, "Answers"}], 
                    ToString[10] -> Blank[]]}]}])& ], {1},
           BaselinePosition->Baseline,
           DefaultBaseStyle->"RadioButtonBar"], 
          StyleBox[
           TemplateBox[{
             StyleBox["\" \"", "ProblemChoiceText", StripOnInput -> False], 
             StyleBox[
              Cell["is an Eclipse-based integrated development environment"], 
              "ProblemChoiceText", StripOnInput -> False]},
            "RowDefault"], "RadioButtonBarLabel",
           StripOnInput->False]}
        },
        AutoDelete->False,
        BaselinePosition->{1, 2},
        GridBoxAlignment->{"Columns" -> {{Left}}, "Rows" -> {{Baseline}}},
        GridBoxItemSize->{"Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}},
        GridBoxSpacings->{"Columns" -> {
            Offset[0.27999999999999997`], {
             Offset[0.21]}, 
            Offset[0.27999999999999997`]}, "Rows" -> {
            Offset[0.2], {
             Offset[0.4]}, 
            Offset[0.2]}}]},
      {GridBox[{
         {
          
          RadioButtonBox[Dynamic[
           MOOCNotebook`Quiz`Private`ans$$, (
            MOOCNotebook`Quiz`Private`ans$$ = #; SetOptions[
              EvaluationNotebook[], 
              TaggingRules -> {"Answers" -> Flatten[{ToString[10] -> #, 
                   DeleteCases[
                    CurrentValue[
                    EvaluationNotebook[], {TaggingRules, "Answers"}], 
                    ToString[10] -> Blank[]]}]}])& ], {2},
           BaselinePosition->Baseline,
           DefaultBaseStyle->"RadioButtonBar"], 
          StyleBox[
           TemplateBox[{
             StyleBox["\" \"", "ProblemChoiceText", StripOnInput -> False], 
             StyleBox[
              Cell[
              "is the native protocol for transferring Wolfram Language\
\[Trademark] symbolic expressions between programs"], "ProblemChoiceText", 
              StripOnInput -> False]},
            "RowDefault"], "RadioButtonBarLabel",
           StripOnInput->False]}
        },
        AutoDelete->False,
        BaselinePosition->{1, 2},
        GridBoxAlignment->{"Columns" -> {{Left}}, "Rows" -> {{Baseline}}},
        GridBoxItemSize->{"Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}},
        GridBoxSpacings->{"Columns" -> {
            Offset[0.27999999999999997`], {
             Offset[0.21]}, 
            Offset[0.27999999999999997`]}, "Rows" -> {
            Offset[0.2], {
             Offset[0.4]}, 
            Offset[0.2]}}]},
      {GridBox[{
         {
          
          RadioButtonBox[Dynamic[
           MOOCNotebook`Quiz`Private`ans$$, (
            MOOCNotebook`Quiz`Private`ans$$ = #; SetOptions[
              EvaluationNotebook[], 
              TaggingRules -> {"Answers" -> Flatten[{ToString[10] -> #, 
                   DeleteCases[
                    CurrentValue[
                    EvaluationNotebook[], {TaggingRules, "Answers"}], 
                    ToString[10] -> Blank[]]}]}])& ], {3},
           BaselinePosition->Baseline,
           DefaultBaseStyle->"RadioButtonBar"], 
          StyleBox[
           TemplateBox[{
             StyleBox["\" \"", "ProblemChoiceText", StripOnInput -> False], 
             StyleBox[
              Cell[
              "calls Mathematica\[RegisteredTrademark] through a web server"],
               "ProblemChoiceText", StripOnInput -> False]},
            "RowDefault"], "RadioButtonBarLabel",
           StripOnInput->False]}
        },
        AutoDelete->False,
        BaselinePosition->{1, 2},
        GridBoxAlignment->{"Columns" -> {{Left}}, "Rows" -> {{Baseline}}},
        GridBoxItemSize->{"Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}},
        GridBoxSpacings->{"Columns" -> {
            Offset[0.27999999999999997`], {
             Offset[0.21]}, 
            Offset[0.27999999999999997`]}, "Rows" -> {
            Offset[0.2], {
             Offset[0.4]}, 
            Offset[0.2]}}]},
      {GridBox[{
         {
          
          RadioButtonBox[Dynamic[
           MOOCNotebook`Quiz`Private`ans$$, (
            MOOCNotebook`Quiz`Private`ans$$ = #; SetOptions[
              EvaluationNotebook[], 
              TaggingRules -> {"Answers" -> Flatten[{ToString[10] -> #, 
                   DeleteCases[
                    CurrentValue[
                    EvaluationNotebook[], {TaggingRules, "Answers"}], 
                    ToString[10] -> Blank[]]}]}])& ], {4},
           BaselinePosition->Baseline,
           DefaultBaseStyle->"RadioButtonBar"], 
          StyleBox[
           TemplateBox[{
             StyleBox["\" \"", "ProblemChoiceText", StripOnInput -> False], 
             StyleBox[
              Cell[
              "makes it easy to discover and connect to Wolfram Engines\
\[Trademark] installed on remote computers"], "ProblemChoiceText", 
              StripOnInput -> False]},
            "RowDefault"], "RadioButtonBarLabel",
           StripOnInput->False]}
        },
        AutoDelete->False,
        BaselinePosition->{1, 2},
        GridBoxAlignment->{"Columns" -> {{Left}}, "Rows" -> {{Baseline}}},
        GridBoxItemSize->{"Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}},
        GridBoxSpacings->{"Columns" -> {
            Offset[0.27999999999999997`], {
             Offset[0.21]}, 
            Offset[0.27999999999999997`]}, "Rows" -> {
            Offset[0.2], {
             Offset[0.4]}, 
            Offset[0.2]}}]}
     },
     GridBoxAlignment->{"Columns" -> {{Left}}, "Rows" -> {{Baseline}}}], 
    "Deploy"],
   RadioButtonBar[
    Dynamic[
    MOOCNotebook`Quiz`Private`ans$$, (MOOCNotebook`Quiz`Private`ans$$ = #; 
     SetOptions[
       EvaluationNotebook[], 
       TaggingRules -> {"Answers" -> Flatten[{ToString[10] -> #, 
            DeleteCases[
             CurrentValue[
              EvaluationNotebook[], {TaggingRules, "Answers"}], ToString[10] -> 
             Blank[]]}]}])& ], {1 -> Row[{
        Style[" ", "ProblemChoiceText"], 
        Style[
         RawBoxes[
          Cell["is an Eclipse-based integrated development environment"]], 
         "ProblemChoiceText"]}], 2 -> Row[{
        Style[" ", "ProblemChoiceText"], 
        Style[
         RawBoxes[
          Cell[
          "is the native protocol for transferring Wolfram Language\
\[Trademark] symbolic expressions between programs"]], "ProblemChoiceText"]}],
      3 -> Row[{
        Style[" ", "ProblemChoiceText"], 
        Style[
         RawBoxes[
          Cell[
          "calls Mathematica\[RegisteredTrademark] through a web server"]], 
         "ProblemChoiceText"]}], 4 -> Row[{
        Style[" ", "ProblemChoiceText"], 
        Style[
         RawBoxes[
          Cell[
          "makes it easy to discover and connect to Wolfram Engines\
\[Trademark] installed on remote computers"]], "ProblemChoiceText"]}]}, 
    Appearance -> "Vertical", BaselinePosition -> Baseline]],
  DynamicModuleValues:>{}]], "ProblemChoiceGrid"],

Cell[BoxData[
 DynamicModuleBox[{$CellContext`buttonLabel$$ = "Get Results"}, 
  DynamicBox[ToBoxes[
    If[
     Not[
      TrueQ[
       CurrentValue[
        EvaluationNotebook[], {TaggingRules, "QuizChecked"}, False]]], 
     MouseAppearance[
      Button[
       Style[$CellContext`buttonLabel$$, "CheckButtonText", 
        ShowStringCharacters -> False], $CellContext`buttonLabel$$ = Pane[
          Row[{" CHECKING ", 
            ProgressIndicator[Appearance -> "Percolate"]}]]; 
       MOOC`CheckAnswers[]; 
       MOOC`SetQuizChecked[True]; $CellContext`buttonLabel$$ = "Get Results"; 
       Null, BaseStyle -> "CheckButton", Evaluator -> Automatic, Method -> 
       "Queued"], "LinkHand"], 
     Module[{
      MOOCNotebook`Quiz`Private`answers$, 
       MOOCNotebook`Quiz`Private`correctAnswers$, 
       MOOCNotebook`Quiz`Private`numberOfAnswers$, 
       MOOCNotebook`Quiz`Private`corr$, 
       MOOCNotebook`Quiz`Private`percentCorrect$}, 
      MOOCNotebook`Quiz`Private`answers$ = CurrentValue[
         EvaluationNotebook[], {TaggingRules, "Answers"}]; 
      MOOCNotebook`Quiz`Private`numberOfAnswers$ = 
       Length[MOOCNotebook`Quiz`Private`answers$]; 
      MOOCNotebook`Quiz`Private`correctAnswers$ = CurrentValue[
         EvaluationNotebook[], {TaggingRules, "CorrectAnswers"}]; If[
        And[
         MemberQ[{Inherited, $Failed}, 
          MOOCNotebook`Quiz`Private`correctAnswers$], False], 
        MOOC`SetTaggingRule["CorrectAnswers", 
         Map[# -> False& , 
          Range[
           Length[MOOCNotebook`Quiz`Private`answers$]]]]]; If[
        And[
         ListQ[MOOCNotebook`Quiz`Private`correctAnswers$], 
         Length[MOOCNotebook`Quiz`Private`correctAnswers$] > 0], 
        MOOCNotebook`Quiz`Private`corr$ = Map[ToString, {
            Length[
             Select[MOOCNotebook`Quiz`Private`correctAnswers$, TrueQ[
               Part[#, 2]]& ]], 
            Length[MOOCNotebook`Quiz`Private`correctAnswers$]}]; 
        MOOCNotebook`Quiz`Private`percentCorrect$ = StringJoin[
           ToString[
            Round[100 (Length[
                Select[MOOCNotebook`Quiz`Private`correctAnswers$, TrueQ[
                  Part[#, 2]]& ]]/Length[
              MOOCNotebook`Quiz`Private`correctAnswers$])]], "%"], 
        MOOCNotebook`Quiz`Private`corr$ = {"0", 
           ToString[
            Length[MOOCNotebook`Quiz`Private`answers$]]}; 
        MOOCNotebook`Quiz`Private`percentCorrect$ = "0"]; 
      With[{MOOCNotebook`Quiz`Private`percent$ = 
         MOOCNotebook`Quiz`Private`percentCorrect$, 
         MOOCNotebook`Quiz`Private`correct$ = 
         MOOCNotebook`Quiz`Private`corr$}, 
        Grid[{{
           Style["Quiz Results", "QuizResultsText"]}, {
           Row[{
             Style["Your score is ", "ScoreText"], 
             Style[
             MOOCNotebook`Quiz`Private`percent$, "ScoreText", FontFamily -> 
              "Source Sans Pro Semibold", AutoMultiplicationSymbol -> 
              False]}]}, {
           Style[
            StringJoin["You answered ", 
             Part[MOOCNotebook`Quiz`Private`correct$, 1], " out of ", 
             Part[MOOCNotebook`Quiz`Private`correct$, 2], 
             " problems correctly.  Your quiz score has been recorded."], 
            "NumProbsCorrectText"]}, 
          If[False, {
            Row[
             Flatten[{
               Map[{
                 PaneSelector[{True -> Image[CompressedData["
1:eJxTTMoPSmNiYGAo5gASQYnljkVFiZXBAkBOaF5xZnpeaopnXklqemqRRRIz
UFADiFWAmIVhQACjTJBMHgMbA9fAWI8CGNUL1ae7HHD5b9hvuI+BmYFzMLgF
hvXb9DcB3cQ2GNwygG7C6RYY1mvWXQ9UxzwY3ALD2jXaS2nsJqLdAsPykfLl
g8Ut4PxGmzJgRLiFWZBZcrC4RcZPKtNxh+NXfn1+h4F2i6SHeAJMj/1W+488
Gjzm1HaLyVST48S4RdxFPNp5n/NfZL0E3ES6W6abnGTmZOYnxy3IbuJU4NSl
l1uErYT9HPc4/sZnlt0Gu9dIbqKdWyyEfYFu+UWMmVA36dDKLSAAShug+CDW
bMedjt9p5Ra4mzR5LIH2fCPFHlq5BQb4DfidqOkmStxCbTdRwy0wAEzfPsSm
b1q7Be4mSP4n2U3m88wvUdstcDfZCAfgKh9xuOUyMw+zKC3cAgP4ymx6u4VY
N9HTLTAg6S2ZOljcAgOgNtFgcQvcTQFS2YPFLTAg6SWZMljcMgpGwSgYBaOA
fgAAMnZL2A==
                    "], "Byte", ColorSpace -> "RGB", ImageSize -> 
                    Automatic, Interleaving -> True, Magnification -> 0.5], 
                   False -> Image[CompressedData["
1:eJztl7EKwkAMhovn4OhqEYvioKC7q6Or4gNUrMWlQiuI7+fuqpOLTo4+gF6G
g4KlXpJrz6E/pEfb//INLUmuu9rNNzXHcZKGvMz9wzSO/eOiKW+WUbINo2A9
i/ZBGMSTlZAPBzI6MurOt4ZCjE8t99wVop/xGiXIAbkGQox++S6ud395vTes
HLZurrRPBZWtmyvLR2Xr5srzYdmYXPDd83y6bB2mCmDC/3tre08OG8MEFjBh
H6xX13tQ2BgmMBSTsl+xKXu43wh8JpgUtimmaTal7nDZnDpLZXNrO4VtggnC
1BWIdF0oi2mCTWVy2FwmhW2KiWFjexOlB3GZ2L6Qxeb0YE7vtdH3bc05tua6
X/6i5tg8f9Fze5a/rHOKko1zWaVKlSr9sz4GxjG4
                    "], "Byte", 
                    ColorSpace -> "RGB", ImageSize -> Automatic, Interleaving -> 
                    True, Magnification -> 0.5]}, 
                  Part[#, 2]], 
                 Spacer[3], 
                 Style[
                  Part[#, 1], "NumProbsCorrectText"], 
                 Spacer[24]}& , 
                MOOCNotebook`Quiz`Private`correctAnswers$]}]]}, Nothing], 
          If[True, {
            Style[
             StringJoin[
             "In order to be eligible for a certificate of course completion, \
you must score ", 
              ToString[60], "% on all course quizzes."], 
             "NumProbsCorrectText"]}, Nothing], {
           If[
            StringMatchQ[MOOCNotebook`Quiz`Private`percent$, "100%"], 
            Nothing[], 
            Column[{
              Style["You can retake this quiz!", "NumProbsCorrectText"], 
              Style[
              "Select different responses to the quiz problems and get new \
results.", "NumProbsCorrectText"]}, Frame -> None, FrameStyle -> 
             Thickness[0]]]}}, 
         Spacings -> {"Rows" -> {3, 1, 2, 1, 2, 3}, "Columns" -> {3}}]]]], 
    StandardForm],
   ImageSizeCache->{160., {12., 28.}}],
  DynamicModuleValues:>{},
  Initialization:>(
   MOOC`CheckAnswers[] := 
    Module[{MOOCNotebook`Quiz`Private`answers$, 
       MOOCNotebook`Quiz`Private`correctAnswers$, 
       MOOCNotebook`Quiz`Private`results$, MOOCNotebook`Quiz`Private`tags$, 
       MOOCNotebook`Quiz`Private`success$, MOOCNotebook`Quiz`Private`wid$ = 
       ToString[$WolframID], MOOCNotebook`Quiz`Private`wuuid$ = 
       ToString[$WolframUUID]}, 
      MOOCNotebook`Quiz`Private`answers$ = CurrentValue[
         EvaluationNotebook[], {TaggingRules, "Answers"}]; If[
        ListQ[MOOCNotebook`Quiz`Private`answers$], 
        MOOCNotebook`Quiz`Private`answers$ = ExportString[
           Association[MOOCNotebook`Quiz`Private`answers$], "RawJSON"]; 
        With[{MOOCNotebook`Quiz`Private`id$ = ToString[$WolframID], 
           MOOCNotebook`Quiz`Private`uuid$ = ToString[$WolframUUID]}, 
          MOOCNotebook`Quiz`Private`results$ = URLExecute[
            CloudObject[
            "https://www.wolframcloud.com/obj/online-courses/api/daily-study-\
group/get/quiz-verification/204"], {
            "userAnswers" -> MOOCNotebook`Quiz`Private`answers$, "wid" -> 
             MOOCNotebook`Quiz`Private`id$, "wuuid" -> 
             MOOCNotebook`Quiz`Private`uuid$}]]; 
        MOOCNotebook`Quiz`Private`success$ = If[
           StringQ[MOOCNotebook`Quiz`Private`results$], 
           ToExpression[MOOCNotebook`Quiz`Private`results$], $Failed]; 
        MOOCNotebook`Quiz`Private`success$ = SortBy[
           If[
            AssociationQ[MOOCNotebook`Quiz`Private`success$], 
            Normal[MOOCNotebook`Quiz`Private`success$], 
            MOOCNotebook`Quiz`Private`success$], ToExpression[
            First[#]]& ]; If[
          ListQ[MOOCNotebook`Quiz`Private`success$], 
          MOOCNotebook`Quiz`Private`tags$ = MOOC`ResetOptions[
             CurrentValue[
              EvaluationNotebook[], TaggingRules], "CorrectAnswers" -> 
             Normal[MOOCNotebook`Quiz`Private`success$]]; If[
            ListQ[MOOCNotebook`Quiz`Private`tags$], 
            SetOptions[
             EvaluationNotebook[], TaggingRules -> 
             MOOCNotebook`Quiz`Private`tags$]]; 
          With[{MOOCNotebook`Quiz`Private`id$ = ToString[$WolframID], 
             MOOCNotebook`Quiz`Private`uuid$ = ToString[$WolframUUID]}, 
            If[
             And[
              StringQ[
              "https://www.wolframcloud.com/obj/online-courses/daily-study-\
group/api/log/quiz"], 
              StringMatchQ[
              "https://www.wolframcloud.com/obj/online-courses/daily-study-\
group/api/log/quiz", "http*"]], 
             URLExecute[
              CloudObject[
              "https://www.wolframcloud.com/obj/online-courses/daily-study-\
group/api/log/quiz"], {
              "id" -> MOOCNotebook`Quiz`Private`id$, "uuid" -> 
               MOOCNotebook`Quiz`Private`uuid$, "quiznum" -> ToString[204], 
               "correctpercent" -> ToString[
                 Round[Divide[
                    Count[
                    MOOCNotebook`Quiz`Private`success$, Blank[] -> True], 
                    Length[MOOCNotebook`Quiz`Private`success$]] 100]], 
               "answers" -> ToString[MOOCNotebook`Quiz`Private`answers$]}]]]; 
          True, $Failed], $Failed]]; MOOC`SetQuizChecked[
      Pattern[MOOCNotebook`Quiz`Private`val, 
       Blank[]]] := 
    MOOC`SetTaggingRule["QuizChecked", MOOCNotebook`Quiz`Private`val]; 
   MOOC`SetTaggingRule[
      Pattern[MOOCNotebook`Quiz`Private`tag, 
       Blank[]], 
      Pattern[MOOCNotebook`Quiz`Private`val, 
       Blank[]]] := 
    Module[{MOOCNotebook`Quiz`Private`tags}, 
      MOOCNotebook`Quiz`Private`tags = MOOC`ResetOptions[
         CurrentValue[
          EvaluationNotebook[], TaggingRules], MOOCNotebook`Quiz`Private`tag -> 
         MOOCNotebook`Quiz`Private`val]; If[
        ListQ[MOOCNotebook`Quiz`Private`tags], 
        SetOptions[
         EvaluationNotebook[], TaggingRules -> 
         MOOCNotebook`Quiz`Private`tags]]]; MOOC`ResetOptions[
      Pattern[MOOCNotebook`Quiz`Private`h, 
       Blank[]][
       Pattern[MOOCNotebook`Quiz`Private`stuff, 
        BlankNullSequence[]], 
       PatternTest[
        Pattern[MOOCNotebook`Quiz`Private`opts, 
         BlankNullSequence[]], OptionQ]], 
      PatternTest[
       Pattern[MOOCNotebook`Quiz`Private`newopts, 
        BlankSequence[]], OptionQ]] := 
    MOOCNotebook`Quiz`Private`h[MOOCNotebook`Quiz`Private`stuff, 
      Apply[Sequence, 
       Flatten[{MOOCNotebook`Quiz`Private`newopts}]], 
      Apply[Sequence, 
       DeleteCases[{MOOCNotebook`Quiz`Private`opts}, 
        Blank[][
         Apply[Alternatives, 
          Part[
           Flatten[{MOOCNotebook`Quiz`Private`newopts}], All, 1]], 
         Blank[]]]]]; MOOC`ResetOptions[
      Pattern[MOOCNotebook`Quiz`Private`h, 
       Blank[]][
       Pattern[MOOCNotebook`Quiz`Private`stuff, 
        BlankNullSequence[]]], 
      PatternTest[
       Pattern[MOOCNotebook`Quiz`Private`newopts, 
        BlankSequence[]], OptionQ]] := 
    MOOCNotebook`Quiz`Private`h[
     MOOCNotebook`Quiz`Private`stuff, 
      MOOCNotebook`Quiz`Private`newopts])]], "ResultsGrid"],

Cell[TextData[StyleBox["", "SmallText",
 FontColor->GrayLevel[0.6]]], "Text",
 ShowCellBracket->False,
 CellTags->"version"]
},
WindowSize->{775, 872},
WindowMargins->{{Automatic, 418}, {49, Automatic}},
ShowCellBracket->False,
TaggingRules->{
 "QuizNumber" -> 204, "QuizChecked" -> False, 
  "Answers" -> {
   "1" -> 0, "10" -> 0, "2" -> 0, "3" -> 0, "4" -> 0, "5" -> 0, "6" -> 0, "7" -> 
    0, "8" -> 0, "9" -> 0}},
FrontEndVersion->"12.2 for Mac OS X x86 (64-bit) (December 12, 2020)",
StyleDefinitions->Notebook[{
   Cell[
    StyleData[StyleDefinitions -> "Default.nb"]], 
   Cell[
    StyleData["Text"], FontFamily -> "Source Sans Pro"], 
   Cell[
    StyleData["ProblemTitle", StyleDefinitions -> StyleData["Text"]], 
    Editable -> False, Deletable -> False, 
    CellMargins -> {{70, Inherited}, {15, 80}}, FontSize -> 40, FontColor -> 
    RGBColor[0.9882352941176471, 0.43137254901960786`, 0.12941176470588237`]], 
   Cell[
    StyleData["ProblemSection"], Editable -> False, Deletable -> False, 
    CellDingbat -> Dynamic[
      If[
       TrueQ[
        CurrentValue[
         EvaluationNotebook[], {TaggingRules, "QuizChecked"}, False]], 
       If[
        TrueQ[
         CurrentValue[
          EvaluationNotebook[], {TaggingRules, "CorrectAnswers", 
           CurrentValue[
            EvaluationCell[], {TaggingRules, "QuestionNum"}]}]], 
        Cell[
         BoxData[
          GraphicsBox[
           TagBox[
            RasterBox[CompressedData["
1:eJxTTMoPSmNiYGAo5gASQYnljkVFiZXBAkBOaF5xZnpeaopnXklqemqRRRIz
UFAOiFWAmIVhQACjTJBMHgMbA9fAWI8CGNUL1ae7HHD5b9hvuI+BmYFzMLgF
hvXb9DcB3cQ2GNwygG7C6RYY1mvWXQ9UxzwY3ALD2jXaS2nsJqLdAsPykfLl
g8Ut4PxGmzJgRLiFWZBZcrC4RcZPKtNxh+NXfn1+h4F2i6SHeAJMj/1W+488
Gjzm1HaLyVST48S4RdxFPNp5n/NfZL0E3ES6W6abnGTmZOYnxy3IbuJU4NSl
l1uErYT9HPc4/sZnlt0Gu9dIbqKdWyyEfYFu+UWMmVA36dDKLSAAShug+CDW
bMedjt9p5Ra4mzR5LIH2fCPFHlq5BQb4DfidqOkmStxCbTdRwy0wAEzfPsSm
b1q7Be4mSP4n2U3m88wvUdstcDfZCAfgKh9xuOUyMw+zKC3cAgP4ymx6u4VY
N9HTLTAg6S2ZOljcAgOgNtFgcQvcTQFS2YPFLTAg6SWZQku3AADRKkvO
             "], {{0,
              30}, {36, 0}}, {0, 255}, ColorFunction -> RGBColor], 
            BoxForm`ImageTag[
            "Byte", ColorSpace -> "RGB", Interleaving -> True, Magnification -> 
             0.5], Selectable -> False], DefaultBaseStyle -> "ImageGraphics", 
           ImageSize -> Magnification[0.5], ImageSizeRaw -> {36, 30}, 
           PlotRange -> {{0, 36}, {0, 30}}]]], 
        Cell[
         BoxData[
          GraphicsBox[
           TagBox[
            RasterBox[CompressedData["
1:eJzF1zELgkAUAGDpGhpbk0iMhoLaWxtbjX6AkkmLgQbR/2tvramlpsZ+QPmg
A6FD77136sEp6rv3Dcp7pxvsvW3Lsqy0kx08/7hIEv+06mYX6zjdRXG4WcaH
MAqTeSCym4PfbFv/YyLE7NyzL64QI8Vj1IAckGssxLQs7mo7j7cz/MCZY+vm
ysfJSbV1c6niqLZurqI4rI3JBe+9KE7X1jHlBBO+33vfeXFsjAkWmLAOzjfb
eVJsjAmGNCnrpU1Zw31HEGfCpNimTNM2pe5wbU6dpdrc2k6xTZgwMHUFZr4u
1GWasKkmx+aaFNuUibGxvYnSg7gmti+obE4P5vTeJvp+U/ucpvZ1ZfFV7WOL
4qvet6vi6/pPkaOu/7IvXXgxrg==
             "], {{0, 30}, {30, 0}}, {0, 255}, 
             ColorFunction -> RGBColor], 
            BoxForm`ImageTag[
            "Byte", ColorSpace -> "RGB", Interleaving -> True, Magnification -> 
             0.5], Selectable -> False], DefaultBaseStyle -> "ImageGraphics", 
           ImageSize -> Magnification[0.5], ImageSizeRaw -> {30, 30}, 
           PlotRange -> {{0, 30}, {0, 30}}]]]], ""]], 
    CellMargins -> {{70, Inherited}, {8, 15}}, CounterIncrements -> 
    "ProblemSection", FontFamily -> "Source Sans Pro Semibold", FontSize -> 
    18, FontVariations -> {"CapsType" -> "AllCaps"}], 
   Cell[
    StyleData["ProblemSectionNoFeedback"], Editable -> False, Deletable -> 
    False, CellMargins -> {{70, Inherited}, {8, 15}}, CounterIncrements -> 
    "ProblemSection", FontFamily -> "Source Sans Pro Semibold", FontSize -> 
    18, FontVariations -> {"CapsType" -> "AllCaps"}], 
   Cell[
    StyleData["ProblemCaption", StyleDefinitions -> StyleData["Text"]], 
    Editable -> False, Deletable -> False, 
    CellMargins -> {{70, Inherited}, {15, 7}}, FontSize -> 21, FontColor -> 
    GrayLevel[0]], 
   Cell[
    StyleData["ProblemChoiceText", StyleDefinitions -> StyleData["Text"]], 
    Editable -> False, Deletable -> False, ShowStringCharacters -> False, 
    FontSize -> 18, FontColor -> GrayLevel[0]], 
   Cell[
    StyleData["ProblemChoiceGrid"], Editable -> False, Deletable -> False, 
    CellMargins -> {{70, Inherited}, {45, 0}}], 
   Cell[
    StyleData["CheckButton"], 
    CellMargins -> {{70, Inherited}, {Inherited, Inherited}}, 
    ButtonBoxOptions -> {
     Background -> 
      RGBColor[0.9882352941176471, 0.43137254901960786`, 
        0.12941176470588237`], ImageSize -> {160, 40}}], 
   Cell[
    StyleData["CheckButtonText"], FontFamily -> "Source Sans Pro Semibold", 
    FontSize -> 18, FontVariations -> {"CapsType" -> "AllCaps"}, FontColor -> 
    GrayLevel[1]], 
   Cell[
    StyleData["QuizResultsText"], FontFamily -> "Source Sans Pro Semibold", 
    FontSize -> 20, FontVariations -> {"CapsType" -> "AllCaps"}, FontColor -> 
    RGBColor[0.29411764705882354`, 0.4, 0.5372549019607843]], 
   Cell[
    StyleData["ScoreText"], FontFamily -> "Source Sans Pro", FontSize -> 22, 
    FontColor -> GrayLevel[0]], 
   Cell[
    StyleData["ResultsGrid"], Editable -> False, Deletable -> False, 
    CellMargins -> {{70, Inherited}, {70, 0}}, ShowStringCharacters -> False, 
    GridBoxOptions -> {FrameStyle -> Directive[
        Thickness[Large], 
        RGBColor[0.4549019607843137, 0.6196078431372549, 0.7843137254901961]],
       GridBoxAlignment -> {"Columns" -> {{Left}}}, 
      GridBoxBackground -> {"Columns" -> {{
           RGBColor[
           0.9490196078431372, 0.9647058823529412, 0.9725490196078431]}}}, 
      GridBoxDividers -> {
       "Columns" -> {True, {False}, True}, "Rows" -> {True, {False}, True}}, 
      GridBoxItemSize -> {"Columns" -> {{36}}}, 
      GridBoxSpacings -> {"Columns" -> {Automatic, {
           Offset[0.5599999999999999]}, Automatic}, "Rows" -> {Automatic, {
           Offset[0.4]}, Automatic}}}], 
   Cell[
    StyleData["NumProbsCorrectText"], FontFamily -> "Source Sans Pro", 
    FontSize -> 17], 
   Cell[
    StyleData["InlineFormula"], ShowStringCharacters -> True, 
    MenuSortingValue -> 10000]}, Visible -> False, 
  TaggingRules -> {"QuizChecked" -> False}, FrontEndVersion -> 
  "12.2 for Mac OS X x86 (64-bit) (December 12, 2020)", StyleDefinitions -> 
  "PrivateStylesheetFormatting.nb"]
]
(* End of Notebook Content *)

(* Internal cache information *)
(*CellTagsOutline
CellTagsIndex->{
 "version"->{
  Cell[209893, 4614, 124, 3, 70, "Text",ExpressionUUID->"1a04773a-7554-4356-8152-1ef998d435f5",
   CellTags->"version"]}
 }
*)
(*CellTagsIndex
CellTagsIndex->{
 {"version", 216435, 4760}
 }
*)
(*NotebookFileOutline
Notebook[{
Cell[558, 20, 30, 0, 70, "ProblemTitle",ExpressionUUID->"e7079dc7-9e17-41a2-b4e1-8abb0d8378b3"],
Cell[591, 22, 84, 1, 70, "ProblemSectionNoFeedback",ExpressionUUID->"0192f6c8-aaaf-4e39-a96e-6bddfcfe187c"],
Cell[678, 25, 170, 5, 70, "ProblemCaption",ExpressionUUID->"e31d8b3a-741d-4d1f-81af-5b5e98084c40"],
Cell[CellGroupData[{
Cell[873, 34, 426, 10, 70, "Input",ExpressionUUID->"9bc88db6-67ab-4685-ba93-308a87010625"],
Cell[1302, 46, 13605, 259, 70, "Output",ExpressionUUID->"81a8b99e-d8e5-4517-925a-0d00fd193b12"]
}, Open  ]],
Cell[14922, 308, 7422, 190, 70, "ProblemChoiceGrid",ExpressionUUID->"8de2060e-6610-4b6f-be23-ea7972fbbd5c"],
Cell[22347, 500, 84, 1, 70, "ProblemSectionNoFeedback",ExpressionUUID->"ee04b257-8ac2-4b80-9a3c-9af872d9c283"],
Cell[22434, 503, 449, 9, 70, "ProblemCaption",ExpressionUUID->"549fb033-61f2-45c8-9240-fd3e35ee1687"],
Cell[CellGroupData[{
Cell[22908, 516, 2240, 52, 70, "Input",ExpressionUUID->"efd59168-eaf1-4f23-b5a1-f601b90f2ea6"],
Cell[25151, 570, 37033, 693, 70, "Output",ExpressionUUID->"7729ea79-40fa-44c6-9a43-bdb008aeead7"]
}, Open  ]],
Cell[62199, 1266, 7450, 190, 70, "ProblemChoiceGrid",ExpressionUUID->"4d11c55f-d05d-46a7-9fbb-904a57dcae15"],
Cell[69652, 1458, 84, 1, 70, "ProblemSectionNoFeedback",ExpressionUUID->"ea92a730-a055-449b-9783-d07f4f4118a1"],
Cell[69739, 1461, 195, 5, 70, "ProblemCaption",ExpressionUUID->"d0fd66c5-0408-4242-8de9-c8a27ed759d0"],
Cell[CellGroupData[{
Cell[69959, 1470, 544, 15, 70, "Input",ExpressionUUID->"d595ed5f-3839-4777-aeb8-5ae4b92182a8"],
Cell[70506, 1487, 27872, 526, 70, "Output",ExpressionUUID->"c783accb-0cd3-4823-b626-0f3e30609e8d"]
}, Open  ]],
Cell[98393, 2016, 7420, 190, 70, "ProblemChoiceGrid",ExpressionUUID->"8f830273-23fe-4786-9976-21309f3b11be"],
Cell[105816, 2208, 84, 1, 70, "ProblemSectionNoFeedback",ExpressionUUID->"7127e0d1-7af8-4c8b-b487-a55f5fdcec5e"],
Cell[105903, 2211, 202, 5, 70, "ProblemCaption",ExpressionUUID->"e18388c1-c83d-4f2e-893b-05b4d34dd0ce"],
Cell[CellGroupData[{
Cell[106130, 2220, 1258, 33, 70, "Input",ExpressionUUID->"37163dcd-883e-4be2-b8db-ce57755b4aac"],
Cell[107391, 2255, 35830, 673, 70, "Output",ExpressionUUID->"c0fcc9a9-6ea8-4043-83ff-b51b4e8fc9df"]
}, Open  ]],
Cell[143236, 2931, 7594, 194, 70, "ProblemChoiceGrid",ExpressionUUID->"6fac584e-1901-4214-a059-e29c15bd1a91"],
Cell[150833, 3127, 84, 1, 70, "ProblemSectionNoFeedback",ExpressionUUID->"86bc8d00-c7b4-4204-89cc-f622bd7ca70e"],
Cell[150920, 3130, 157, 4, 70, "ProblemCaption",ExpressionUUID->"78b9a5ea-abf2-443d-9cc0-38eb9c232a0a"],
Cell[151080, 3136, 7581, 190, 70, "ProblemChoiceGrid",ExpressionUUID->"8e18f5e2-3492-457d-bcff-037a0bacc251"],
Cell[158664, 3328, 84, 1, 70, "ProblemSectionNoFeedback",ExpressionUUID->"8357c8c6-1055-4450-8dba-20d6abaa971a"],
Cell[158751, 3331, 209, 6, 70, "ProblemCaption",ExpressionUUID->"feee6a38-a3de-4b0c-9104-9b5f25dab3ef"],
Cell[158963, 3339, 7818, 201, 70, "ProblemChoiceGrid",ExpressionUUID->"f4b432a4-a375-41a1-a77c-03a975dda655"],
Cell[166784, 3542, 84, 1, 70, "ProblemSectionNoFeedback",ExpressionUUID->"83b48536-d084-4538-9677-055477ffb489"],
Cell[166871, 3545, 307, 7, 70, "ProblemCaption",ExpressionUUID->"7c7b0ba2-c031-47db-aab2-1f0f4adc4b95"],
Cell[167181, 3554, 7591, 195, 70, "ProblemChoiceGrid",ExpressionUUID->"6dbb84c9-72eb-4fbd-9ea6-7b70f7151992"],
Cell[174775, 3751, 84, 1, 70, "ProblemSectionNoFeedback",ExpressionUUID->"3e924ac9-0eca-4c70-9b6b-21902507e8d7"],
Cell[174862, 3754, 282, 7, 70, "ProblemCaption",ExpressionUUID->"d26b64e5-6ddd-4aea-9fa3-40a0e1773a82"],
Cell[175147, 3763, 7518, 191, 70, "ProblemChoiceGrid",ExpressionUUID->"6d35165c-7add-46d1-a6fa-e363da8fb070"],
Cell[182668, 3956, 84, 1, 70, "ProblemSectionNoFeedback",ExpressionUUID->"350a09ba-9167-4327-b073-d46bb53b9449"],
Cell[182755, 3959, 61, 0, 70, "ProblemCaption",ExpressionUUID->"58fa9cb2-1138-4045-b7ec-80d7e9198fdc"],
Cell[182819, 3961, 1211, 33, 70, "Input",ExpressionUUID->"23994d9b-a76a-4532-a029-e2c431bf87b6"],
Cell[184033, 3996, 7131, 183, 70, "ProblemChoiceGrid",ExpressionUUID->"e6cc3fa5-ef55-4973-b7e5-f0209f1e934d"],
Cell[191167, 4181, 86, 1, 70, "ProblemSectionNoFeedback",ExpressionUUID->"06b996cb-fc4f-47c0-a721-8e7c5b8baee2"],
Cell[191256, 4184, 97, 1, 70, "ProblemCaption",ExpressionUUID->"d9af71b4-976e-4a0c-9a55-3ada8444ecbd"],
Cell[191356, 4187, 99, 2, 70, "ProblemCaption",ExpressionUUID->"3c9fb6c3-3a91-410f-b77e-1e82eb677846"],
Cell[191458, 4191, 7454, 183, 70, "ProblemChoiceGrid",ExpressionUUID->"db843c9f-583c-434e-b80e-0f91f23c2183"],
Cell[198915, 4376, 10975, 236, 70, "ResultsGrid",ExpressionUUID->"50d7ebb9-a070-48e2-9d0d-b18f84bd9801"],
Cell[209893, 4614, 124, 3, 70, "Text",ExpressionUUID->"1a04773a-7554-4356-8152-1ef998d435f5",
 CellTags->"version"]
}
]
*)

(* End of internal cache information *)
